% Options for packages loaded elsewhere
\PassOptionsToPackage{unicode}{hyperref}
\PassOptionsToPackage{hyphens}{url}
\PassOptionsToPackage{dvipsnames,svgnames,x11names}{xcolor}
\documentclass[
  9pt,
]{extreport}
\usepackage{xcolor}
\usepackage[margin=0.85in]{geometry}
\usepackage{amsmath,amssymb}
\setcounter{secnumdepth}{-\maxdimen} % remove section numbering
\usepackage{iftex}
\ifPDFTeX
  \usepackage[T1]{fontenc}
  \usepackage[utf8]{inputenc}
  \usepackage{textcomp} % provide euro and other symbols
\else % if luatex or xetex
  \usepackage{unicode-math} % this also loads fontspec
  \defaultfontfeatures{Scale=MatchLowercase}
  \defaultfontfeatures[\rmfamily]{Ligatures=TeX,Scale=1}
\fi
\usepackage{lmodern}
\ifPDFTeX\else
  % xetex/luatex font selection
  \setmainfont[]{STIX Two Text}
  \setmathfont[]{STIX Two Math}
\fi
% Use upquote if available, for straight quotes in verbatim environments
\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
\IfFileExists{microtype.sty}{% use microtype if available
  \usepackage[]{microtype}
  \UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
}{}
\makeatletter
\@ifundefined{KOMAClassName}{% if non-KOMA class
  \IfFileExists{parskip.sty}{%
    \usepackage{parskip}
  }{% else
    \setlength{\parindent}{0pt}
    \setlength{\parskip}{6pt plus 2pt minus 1pt}}
}{% if KOMA class
  \KOMAoptions{parskip=half}}
\makeatother
\usepackage{color}
\usepackage{fancyvrb}
\newcommand{\VerbBar}{|}
\newcommand{\VERB}{\Verb[commandchars=\\\{\}]}
\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
% Add ',fontsize=\small' for more characters per line
\newenvironment{Shaded}{}{}
\newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{#1}}}
\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.49,0.56,0.16}{#1}}
\newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
\newcommand{\BuiltInTok}[1]{\textcolor[rgb]{0.00,0.50,0.00}{#1}}
\newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{#1}}}
\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.53,0.00,0.00}{#1}}
\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{#1}}}
\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{#1}}
\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
\newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.73,0.13,0.13}{\textit{#1}}}
\newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{#1}}}
\newcommand{\ExtensionTok}[1]{#1}
\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{#1}}
\newcommand{\ImportTok}[1]{\textcolor[rgb]{0.00,0.50,0.00}{\textbf{#1}}}
\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{#1}}}
\newcommand{\NormalTok}[1]{#1}
\newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.40,0.40,0.40}{#1}}
\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{#1}}
\newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.74,0.48,0.00}{#1}}
\newcommand{\RegionMarkerTok}[1]{#1}
\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.73,0.40,0.53}{#1}}
\newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.10,0.09,0.49}{#1}}
\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
\newcommand{\WarningTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
\setlength{\emergencystretch}{3em} % prevent overfull lines
\providecommand{\tightlist}{%
  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
% Cyberpunk dark theme for docs/reference.pdf, mirroring docs/index.html.
% Injected by scripts/reference_pdf.sh via --include-in-header. The bash
% script substitutes /Users/wizard/RustroverProjects/strykelang/docs/.fonts/ with an absolute path to docs/.fonts/.

\usepackage{xcolor}
\usepackage{pagecolor}
\usepackage{titlesec}
\usepackage{tcolorbox}

% Palette from docs/hud-static.css (data-theme="dark").
\definecolor{bgPrimary}{HTML}{05050A}
\definecolor{bgCard}{HTML}{0D0D1A}
\definecolor{accentPink}{HTML}{FF2A6D}
\definecolor{neonCyan}{HTML}{05D9E8}
\definecolor{neonMagenta}{HTML}{D300C5}
\definecolor{neonGreen}{HTML}{39FF14}
\definecolor{textPrim}{HTML}{E0F0FF}
\definecolor{textDim}{HTML}{7A8BA8}
\definecolor{borderDim}{HTML}{1A1A3E}

\pagecolor{bgPrimary}
\color{textPrim}

% Variable Orbitron — wght axis, 400 regular / 700 bold / 900 black.
\setsansfont{Orbitron}[
    Path=/Users/wizard/RustroverProjects/strykelang/docs/.fonts/,
    Extension=.ttf,
    UprightFont=Orbitron-VF,
    UprightFeatures={RawFeature={+axis={wght=400}}},
    BoldFont=Orbitron-VF,
    BoldFeatures={RawFeature={+axis={wght=700}}},
    Scale=MatchLowercase,
]

% Static Share Tech Mono — single weight.
\setmonofont{ShareTechMono}[
    Path=/Users/wizard/RustroverProjects/strykelang/docs/.fonts/,
    Extension=.ttf,
    UprightFont=ShareTechMono-Regular,
    Scale=MatchLowercase,
]

% Headings: Orbitron, neon. Pandoc emits report-class \chapter / \section /
% \subsection. titlesec*-form is "easy" and supports section and below; for
% \chapter use the full \titleformat with empty label/spacing slots since
% secnumdepth is forced negative (no numbering).
\titleformat{\chapter}[hang]{\sffamily\bfseries\Huge\color{neonCyan}}{}{0pt}{}
\titlespacing*{\chapter}{0pt}{20pt}{20pt}
\titleformat*{\section}{\sffamily\bfseries\LARGE\color{neonMagenta}}
\titleformat*{\subsection}{\sffamily\bfseries\Large\color{accentPink}}
\titleformat*{\subsubsection}{\sffamily\bfseries\large\color{neonCyan}}

% Hyperref already configured by pandoc; override link colors to neon.
% \AtBeginDocument because pandoc loads hyperref AFTER our header-include,
% so \hypersetup is undefined when this file runs. linktoc=all ensures the
% TOC entries (text + page number) inherit linkcolor; without it, dotted
% leaders and page numbers stay near-invisible NavyBlue on the dark bg.
\AtBeginDocument{%
    \hypersetup{%
        linkcolor=neonCyan,%
        urlcolor=neonMagenta,%
        citecolor=neonGreen,%
        filecolor=neonCyan,%
        linktoc=all,%
    }%
}

% Pandoc syntax-highlight blocks live inside a \Shaded environment defined
% in pandoc's template. Override its background to bgCard with a thin border.
% \AtBeginDocument because pandoc defines \Shaded after our header-include.
\AtBeginDocument{%
    \renewenvironment{Shaded}{%
        \begin{tcolorbox}[%
            colback=bgCard,colframe=borderDim,boxrule=0.4pt,arc=1pt,%
            left=4pt,right=4pt,top=2pt,bottom=2pt,%
            before skip=4pt,after skip=4pt%
        ]\color{neonGreen}\ttfamily\small%
    }{\end{tcolorbox}}%
}

% Inline `code` and \texttt: bright cyan.
\renewcommand{\texttt}[1]{{\ttfamily\color{neonCyan}#1}}

% TOC color tweak: dotted leaders → dim, page numbers → cyan.
\makeatletter
\renewcommand{\@dotsep}{1.5}
\makeatother

% Cyberpunk cover page — replaces pandoc's default \maketitle. Big stryke
% wordmark in Orbitron, neon cyan/magenta accents, version + date in dim
% terminal-style mono. \@title / \@author / \@date are populated by pandoc
% from --metadata.
\makeatletter
\renewcommand{\maketitle}{%
    \begin{titlepage}%
    \begin{center}%
    \vspace*{2cm}
    {\sffamily\bfseries\fontsize{12pt}{14pt}\selectfont\color{neonCyan}%
        \rule[0.4ex]{1.5cm}{0.4pt}\hspace{0.5em}// STRYKE //\hspace{0.5em}\rule[0.4ex]{1.5cm}{0.4pt}}%
    \par\vspace{2.5cm}%
    {\sffamily\bfseries\fontsize{72pt}{80pt}\selectfont\color{textPrim}\@title\par}%
    \vspace{1cm}%
    {\color{neonMagenta}\rule{0.5\linewidth}{1pt}\par}%
    \vspace{0.8cm}%
    {\sffamily\bfseries\fontsize{20pt}{24pt}\selectfont\color{neonMagenta}%
        LANGUAGE REFERENCE\par}%
    \vspace{0.4cm}%
    {\sffamily\fontsize{10pt}{12pt}\selectfont\color{textDim}%
        \itshape every builtin · keyword · alias · extension\par}%
    \vfill
    {\ttfamily\color{neonGreen}\Large \@date\par}%
    \vspace{0.5cm}%
    {\ttfamily\color{textDim}\normalsize \@author\par}%
    \vspace{1.5cm}%
    {\sffamily\fontsize{8pt}{10pt}\selectfont\color{borderDim}%
        \rule[0.4ex]{1cm}{0.3pt}\hspace{0.4em}MENKETECHNOLOGIES\hspace{0.4em}\rule[0.4ex]{1cm}{0.3pt}\par}%
    \end{center}%
    \end{titlepage}%
}
\makeatother
\usepackage{bookmark}
\IfFileExists{xurl.sty}{\usepackage{xurl}}{} % add URL line breaks if available
\urlstyle{same}
\hypersetup{
  pdftitle={stryke --- Language Reference},
  pdfauthor={MenkeTechnologies},
  colorlinks=true,
  linkcolor={Maroon},
  filecolor={Maroon},
  citecolor={Blue},
  urlcolor={Blue},
  pdfcreator={LaTeX via pandoc}}

\title{stryke --- Language Reference}
\usepackage{etoolbox}
\makeatletter
\providecommand{\subtitle}[1]{% add subtitle to \maketitle
  \apptocmd{\@title}{\par {\large #1 \par}}{}{}
}
\makeatother
\subtitle{v0.13.0}
\author{MenkeTechnologies}
\date{2026-05-10}

\begin{document}
\maketitle

{
\setcounter{tocdepth}{0}
\tableofcontents
}
\protect\phantomsection\label{ch-parallel-primitives}
\chapter{Parallel Primitives}\label{parallel-primitives}

18 topics

\section{\texorpdfstring{\texttt{pmap}}{pmap}}\label{pmap}

Parallel \texttt{map} powered by rayon\textquotesingle 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 \texttt{progress\ =\textgreater{}\ 1} to get a live
progress bar on STDERR for long-running jobs.

Two equivalent surface syntaxes: • Block form ---
\texttt{pmap\ BLOCK\ LIST} --- element bound to \texttt{\_} • Bare-fn
form --- \texttt{pmap\ FUNC,\ LIST} --- single-arg function name as
first argument

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{my @out = pmap \{ \_ * 2 \} 1:1\_000\_000}
\NormalTok{my @hashes = pmap sha256 @blobs, progress =\textgreater{} 1}
\NormalTok{1:100 |\textgreater{} pmap \{ fetch("https://api.example.com/item/$\_") \} |\textgreater{} e p}

\NormalTok{\# Bare{-}fn form (works for builtins and user{-}defined subs)}
\NormalTok{my @hashes = pmap sha256, @blobs, progress =\textgreater{} 1}
\NormalTok{fn dbl = \_ * 2}
\NormalTok{my @r = pmap dbl, (1:1\_000\_000)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pmaps}}{pmaps}}\label{pmaps}

Streaming parallel \texttt{map} --- returns a lazy iterator that
processes items across all CPU cores using a persistent worker-thread
pool. Unlike \texttt{pmap} which eagerly collects all results into an
array, \texttt{pmaps} 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 \texttt{pmap} for large
inputs.

Best for: • Pipelines with \texttt{take}/\texttt{head} --- avoids
processing the full list • Very large inputs where holding all results
in memory is impractical • Streaming pipelines where you want
progressive output

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{range(0, 1e9) |\textgreater{} pmaps \{ \_ * 2 \} |\textgreater{} take 10 |\textgreater{} ep}
\NormalTok{t 1:1e6 pmaps \{ expensive(\_) \} ep}
\NormalTok{range(0, 1e6) |\textgreater{} pmaps \{ fetch("https://api/item/$\_") \} |\textgreater{} pgreps \{ \_{-}\textgreater{}\{ok\} \} |\textgreater{} ep}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pmap\_chunked}}{pmap\_chunked}}\label{pmap_chunked}

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 \texttt{pmap} when profiling shows rayon overhead
dominates the actual computation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @out = pmap\_chunked 100, \{ \_ ** 2 \} 1:1\_000\_000}
\NormalTok{my @parsed = pmap\_chunked 50, \{ json\_decode \} @json\_strings}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pgrep}}{pgrep}}\label{pgrep}

Parallel \texttt{grep} 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 \texttt{grep} 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 \texttt{grep} may be faster due to lower scheduling overhead.

Two equivalent surface syntaxes: \texttt{pgrep\ \{\ BLOCK\ \}\ LIST} or
\texttt{pgrep\ FUNC,\ LIST}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{my @matches = pgrep \{ /complex\_pattern/ \} @big\_list}
\NormalTok{my @primes = pgrep \{ is\_prime \} 2:1\_000\_000}
\NormalTok{@files |\textgreater{} pgrep \{ {-}s \_ \textgreater{} 1024 \} |\textgreater{} e p}

\NormalTok{\# Bare{-}fn form}
\NormalTok{fn Demo::even = \_ \% 2 == 0}
\NormalTok{my @e = pgrep Demo::even, 1:10  \# (2,4,6,8,10)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pgreps}}{pgreps}}\label{pgreps}

Streaming parallel \texttt{grep} --- returns a lazy iterator that
filters items across all CPU cores. Unlike \texttt{pgrep} which eagerly
collects all matching items, \texttt{pgreps} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{range(0, 1e6) |\textgreater{} pgreps \{ is\_prime(\_) \} |\textgreater{} take 100 |\textgreater{} ep}
\NormalTok{t 1:1e9 pgreps \{ \_ \% 7 == 0 \} take 10 ep}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfor}}{pfor}}\label{pfor}

Parallel \texttt{foreach} 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\textquotesingle t need to collect results. The block
receives each element as \texttt{\_}. Iteration order is
non-deterministic, so the block must be safe to run concurrently.

Two equivalent surface syntaxes: \texttt{pfor\ \{\ BLOCK\ \}\ LIST} or
\texttt{pfor\ FUNC,\ LIST}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{pfor \{ write\_report \} @records}
\NormalTok{pfor \{ compress\_file \} glob("*.log")}
\NormalTok{@urls |\textgreater{} pfor \{ fetch}
\NormalTok{    p "done: $\_" \}}

\NormalTok{\# Bare{-}fn form}
\NormalTok{fn task = ep "did $\_"}
\NormalTok{pfor task, (1, 2, 3)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{psort}}{psort}}\label{psort}

Parallel sort that uses rayon\textquotesingle s parallel merge-sort
algorithm. Accepts an optional comparator block using
\texttt{\$\_0}/\texttt{\$\_1} (or \texttt{\$a}/\texttt{\$b}). For large
lists (10k+ elements), this significantly outperforms the sequential
\texttt{sort} by splitting the array, sorting partitions in parallel,
and merging. The sort is stable --- equal elements retain their relative
order.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @sorted = psort \{ $\_0 \textless{}=\textgreater{} $\_1 \} @big\_list}
\NormalTok{my @by\_name = psort \{ $\_0{-}\textgreater{}\{name\} cmp $\_1{-}\textgreater{}\{name\} \} @records}
\NormalTok{@nums |\textgreater{} psort \{ $a \textless{}=\textgreater{} $b \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pcache}}{pcache}}\label{pcache}

Parallel memoized map --- each element is processed concurrently, but
results are cached by the stringified value of \texttt{\_} 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.

Two equivalent surface syntaxes: \texttt{pcache\ \{\ BLOCK\ \}\ LIST} or
\texttt{pcache\ FUNC,\ LIST}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{my @out = pcache \{ expensive\_lookup \} @list\_with\_dupes}
\NormalTok{my @resolved = pcache \{ dns\_resolve \} @hostnames}

\NormalTok{\# Bare{-}fn form}
\NormalTok{my @resolved = pcache dns\_resolve, @hostnames}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{preduce}}{preduce}}\label{preduce}

Parallel tree-fold using rayon\textquotesingle s \texttt{reduce} ---
splits the list into chunks, reduces each chunk independently, then
merges partial results. The combining operation \textbf{must be
associative} (e.g. \texttt{+}, \texttt{*}, \texttt{max});
non-associative ops will produce incorrect results. Much faster than
sequential \texttt{reduce} on large numeric lists because the tree
structure allows O(log n) merge depth across cores.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $total = preduce \{ $\_0 + $\_1 \} @nums}
\NormalTok{my $biggest = preduce \{ $\_0 \textgreater{} $\_1 ? $\_0 : $\_1 \} @vals}
\NormalTok{my $product = preduce \{ $a * $b \} 1:100}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{preduce\_init}}{preduce\_init}}\label{preduce_init}

Parallel fold with identity value.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $total = preduce\_init 0, \{ $\_0 + $\_1 \} @list}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pmap\_reduce}}{pmap\_reduce}}\label{pmap_reduce}

Fused parallel map + tree reduce.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sum = pmap\_reduce \{ \_*2 \} \{ $\_0 + $\_1 \} @list}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pany}}{pany}}\label{pany}

\texttt{pany\ \{\ COND\ \}\ @list} --- parallel short-circuit
\texttt{any}.

\section{\texorpdfstring{\texttt{pfirst}}{pfirst}}\label{pfirst}

\texttt{pfirst\ \{\ COND\ \}\ @list} --- parallel first matching
element.

\section{\texorpdfstring{\texttt{puniq}}{puniq}}\label{puniq}

\texttt{puniq\ @list} --- parallel unique elements.

\section{\texorpdfstring{\texttt{pflat\_map}}{pflat\_map}}\label{pflat_map}

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.

Two equivalent surface syntaxes: \texttt{pflat\_map\ BLOCK\ LIST} or
\texttt{pflat\_map\ FUNC,\ LIST}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{my @out = pflat\_map expand @list}

\NormalTok{\# Bare{-}fn form}
\NormalTok{fn expand = (\_, \_ * 10)}
\NormalTok{my @r = pflat\_map expand, (1, 2, 3)   \# (1, 10, 2, 20, 3, 30)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pflat\_maps}}{pflat\_maps}}\label{pflat_maps}

Streaming parallel flat-map --- like \texttt{pmaps} but flattens array
results. Returns a lazy iterator.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{range(0, 1e6) |\textgreater{} pflat\_maps \{ [\_, \_ * 10] \} |\textgreater{} ep}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fan}}{fan}}\label{fan}

Execute BLOCK or FUNC N times in parallel (\texttt{\_} = index 0..N-1).
With no count, defaults to the rayon pool size (\texttt{stryke\ -j}).

Two equivalent surface syntaxes: • Block form ---
\texttt{fan\ N\ \{\ BLOCK\ \}} or \texttt{fan\ \{\ BLOCK\ \}} • Bare-fn
form --- \texttt{fan\ N,\ FUNC} or \texttt{fan\ FUNC}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{fan 8 \{ work(\_) \}}
\NormalTok{fan \{ work(\_) \} progress =\textgreater{} 1}

\NormalTok{\# Bare{-}fn form}
\NormalTok{fn tick = ep "tick $\_"}
\NormalTok{fan 8, tick}
\NormalTok{fan tick, progress =\textgreater{} 1   \# uses pool size}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fan\_cap}}{fan\_cap}}\label{fan_cap}

Like \texttt{fan} but captures return values in index order. Two surface
syntaxes: \texttt{fan\_cap\ N\ \{\ BLOCK\ \}} or
\texttt{fan\_cap\ N,\ FUNC}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Block form}
\NormalTok{my @results = fan\_cap 8 \{ compute(\_) \}}

\NormalTok{\# Bare{-}fn form}
\NormalTok{fn compute = \_ * \_}
\NormalTok{my @squares = fan\_cap 8, compute}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-shared-state-concurrency}
\chapter{Shared State \& Concurrency}\label{shared-state-concurrency}

11 topics

\section{\texorpdfstring{\texttt{mysync}}{mysync}}\label{mysync}

Declare shared variables for parallel blocks
(\texttt{Arc\textless{}Mutex\textgreater{}}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{mysync $counter = 0}
\NormalTok{fan 10000 \{ $counter++ \}   \# always exactly 10000}
\NormalTok{mysync @results}
\NormalTok{mysync \%histogram$1}

\NormalTok{Compound ops (\textasciigrave{}++\textasciigrave{}, \textasciigrave{}+=\textasciigrave{}, \textasciigrave{}.=\textasciigrave{}, \textasciigrave{}|=\textasciigrave{}, \textasciigrave{}\&=\textasciigrave{}) are fully atomic.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{async}}{async}}\label{async}

\texttt{async\ \{\ BLOCK\ \}} --- schedule a block for execution on a
background worker thread and return a task handle immediately.

The block begins executing as soon as a thread is available in
stryke\textquotesingle s global rayon thread pool, while the calling
code continues without blocking. To retrieve the result, pass the task
handle to \texttt{await}, which blocks until the task completes and
returns its value. If the block panics, the panic is captured and
re-raised at the \texttt{await} call site. Use \texttt{async} 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 \texttt{fan} or
\texttt{fan\_cap} instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $task = async \{ long\_compute() \}}
\NormalTok{do\_other\_work()}
\NormalTok{my $val = await $task}

\NormalTok{\# Overlapping multiple fetches:}
\NormalTok{my @tasks = map \{ async \{ fetch("https://api.example.com/$\_") \} \} 1:10;}
\NormalTok{my @results = map \{ await \_ \} @tasks}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spawn}}{spawn}}\label{spawn}

\texttt{spawn\ \{\ BLOCK\ \}} --- Rust-style alias for \texttt{async};
schedules a block on a background thread and returns a joinable task
handle.

This is identical to \texttt{async} in every respect --- same thread
pool, same semantics, same \texttt{await} for joining. The name exists
for developers coming from Rust\textquotesingle s \texttt{tokio::spawn}
or \texttt{std::thread::spawn} who find \texttt{spawn} more natural. Use
whichever reads better in your code; mixing \texttt{async} and
\texttt{spawn} in the same program is perfectly fine since they share
the same underlying pool.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $task = spawn \{ expensive\_io() \}}
\NormalTok{my $val = await $task}

\NormalTok{my @handles = map \{ spawn \{ process \} \} @items;}
\NormalTok{my @out = map \{ await \_ \} @handles}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{await}}{await}}\label{await}

\texttt{await\ \$task} --- block the current thread until an async/spawn
task completes and return its result value.

If the background task has already finished by the time \texttt{await}
is called, the result is returned immediately with no scheduling
overhead. If the task panicked, \texttt{await} re-raises the panic as a
die in the calling thread, preserving the original error message and
backtrace. You can \texttt{await} a task exactly once; calling
\texttt{await} 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 \texttt{join\_all} primitive, but \texttt{map\ await\ @tasks}
achieves the same effect.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $task = async \{ 42 \}}
\NormalTok{my $result = await $task              \# 42}

\NormalTok{\# Await with error handling:}
\NormalTok{my $t = spawn \{ die "oops" \}}
\NormalTok{eval \{ await $t \}                     \# $@ eq "oops"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pchannel}}{pchannel}}\label{pchannel}

\texttt{pchannel(N)} --- create a bounded multi-producer multi-consumer
(MPMC) channel with capacity N, returning a \texttt{(\$tx,\ \$rx)} pair.

The transmitter \texttt{\$tx} supports
\texttt{-\textgreater{}send(\$val)} which blocks if the channel is full
(backpressure). The receiver \texttt{\$rx} supports
\texttt{-\textgreater{}recv} which blocks until a value is available,
and \texttt{-\textgreater{}try\_recv} which returns \texttt{undef}
immediately if the channel is empty. Both ends can be cloned and shared
across threads --- clone \texttt{\$tx} with
\texttt{\$tx-\textgreater{}clone} to create additional producers, or
clone \texttt{\$rx} for additional consumers. When all transmitters are
dropped, \texttt{-\textgreater{}recv} on the receiver returns
\texttt{undef} to signal completion. Use \texttt{pchannel} to build
producer-consumer pipelines, rate-limited work queues, or to communicate
between \texttt{async}/\texttt{spawn} tasks.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($tx, $rx) = pchannel(100)}
\NormalTok{async \{ $tx{-}\textgreater{}send(\_) for 1:1000}
\NormalTok{    undef $tx \}}
\NormalTok{while (defined(my $val = $rx{-}\textgreater{}recv)) \{}
\NormalTok{    p $val}
\NormalTok{\}}

\NormalTok{\# Multiple producers:}
\NormalTok{my ($tx, $rx) = pchannel(50)}
\NormalTok{for my $i (1:4) \{}
\NormalTok{    my $t = $tx{-}\textgreater{}clone}
\NormalTok{    spawn \{ $t{-}\textgreater{}send("from worker $i: \_") for 1:100 \}}
\NormalTok{\}}
\NormalTok{undef $tx  \# drop original so channel closes when workers finish}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pselect}}{pselect}}\label{pselect}

\texttt{pselect(@channels)} --- wait on multiple \texttt{pchannel}
receivers.

\section{\texorpdfstring{\texttt{barrier}}{barrier}}\label{barrier}

\texttt{barrier(N)} --- create a synchronization barrier that blocks
until exactly N threads have arrived at the wait point.

Each thread calls \texttt{\$b-\textgreater{}wait} 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 \texttt{std::sync::Barrier} for zero-overhead synchronization.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $b = barrier(4)}
\NormalTok{for my $i (0:3) \{}
\NormalTok{    spawn \{}
\NormalTok{        setup\_phase($i)}
\NormalTok{        $b{-}\textgreater{}wait                      \# all 4 threads sync here}
\NormalTok{        compute\_phase($i)}
\NormalTok{    \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppool}}{ppool}}\label{ppool}

\texttt{ppool(N,\ fn\ \{\ ...\ \})} --- create a persistent thread pool
of N worker threads, each running the provided subroutine in a loop.

The pool is typically paired with a \texttt{pchannel}: workers pull
items from the channel\textquotesingle s receiver, process them, and
optionally send results to an output channel. Unlike \texttt{pmap} which
is a one-shot parallel transform, \texttt{ppool} 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 \texttt{pmap} calls. Workers exit when
their input channel is closed (all transmitters dropped). The pool
object supports \texttt{-\textgreater{}join} to block until all workers
have finished.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($tx, $rx) = pchannel(100)}
\NormalTok{my $pool = ppool 4, fn \{}
\NormalTok{    while (defined(my $job = $rx{-}\textgreater{}recv)) \{}
\NormalTok{        process($job)}
\NormalTok{    \}}
\NormalTok{\}}
\NormalTok{$tx{-}\textgreater{}send(\_) for @work\_items}
\NormalTok{undef $tx                             \# signal completion}
\NormalTok{$pool{-}\textgreater{}join                           \# wait for drain}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deque}}{deque}}\label{deque}

\texttt{deque\ LIST} --- create a double-ended queue initialized with
the given elements.

A deque supports efficient O(1) insertion and removal at both ends via
\texttt{-\textgreater{}push\_front(\$val)},
\texttt{-\textgreater{}push\_back(\$val)},
\texttt{-\textgreater{}pop\_front}, and
\texttt{-\textgreater{}pop\_back}. It also supports
\texttt{-\textgreater{}len} and iteration. Internally backed by a Rust
\texttt{VecDeque}, it is ideal for sliding window algorithms, BFS
traversals, or any scenario where you need fast access to both ends of a
sequence.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $dq = deque(1, 2, 3)}
\NormalTok{$dq{-}\textgreater{}push\_front(0)}
\NormalTok{$dq{-}\textgreater{}push\_back(4)}
\NormalTok{p $dq{-}\textgreater{}pop\_front                      \# 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heap}}{heap}}\label{heap}

\texttt{heap\ LIST} --- create a min-heap (priority queue) from the
given elements.

Elements are heapified on construction so that
\texttt{-\textgreater{}pop} always returns the smallest element in O(log
n) time. \texttt{-\textgreater{}push(\$val)} inserts a new element, also
in O(log n). The heap supports \texttt{-\textgreater{}peek} to inspect
the minimum without removing it, and \texttt{-\textgreater{}len} for the
current size. Internally backed by a Rust \texttt{BinaryHeap} (inverted
for min-heap semantics), it is the go-to structure for top-K queries,
Dijkstra, and merge-K-sorted-lists problems.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $h = heap(5, 3, 8, 1)}
\NormalTok{p $h{-}\textgreater{}pop                             \# 1 (smallest first)}
\NormalTok{p $h{-}\textgreater{}peek                            \# 3 (next smallest)}
\NormalTok{$h{-}\textgreater{}push(0)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{set}}{set}}\label{set}

\texttt{set\ LIST} --- create a set (unique unordered collection) from
the given elements.

Duplicate values are collapsed on construction so the set contains each
value exactly once. The set object provides
\texttt{-\textgreater{}contains(\$val)} for O(1) membership testing,
plus \texttt{-\textgreater{}union(\$s)},
\texttt{-\textgreater{}intersection(\$s)},
\texttt{-\textgreater{}difference(\$s)}, and \texttt{-\textgreater{}len}
methods. Internally backed by a Rust \texttt{HashSet} for performance.
Use \texttt{to\_set} to convert an existing iterator into a set.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = set(1, 2, 3, 2, 1)}
\NormalTok{p $s{-}\textgreater{}contains(2)                     \# 1}
\NormalTok{p $s{-}\textgreater{}len                             \# 3}
\NormalTok{my $both = $s{-}\textgreater{}union(set(3, 4, 5))}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-pipeline-pipe-forward}
\chapter{Pipeline \& Pipe-Forward}\label{pipeline-pipe-forward}

12 topics

\section{\texorpdfstring{\texttt{\textbar{}\textgreater{}}}{\textbar\textgreater{}}}\label{section}

Pipe-forward operator --- threads LHS as first argument of RHS call.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{"hello" |\textgreater{} uc |\textgreater{} rev |\textgreater{} p              \# OLLEH}
\NormalTok{1:10 |\textgreater{} grep \_ \textgreater{} 5 |\textgreater{} map \_ * 2 |\textgreater{} e p}
\NormalTok{$url |\textgreater{} fetch\_json |\textgreater{} json\_jq \textquotesingle{}.name\textquotesingle{} |\textgreater{} p}
\NormalTok{"hello world" |\textgreater{} s/world/perl/ |\textgreater{} p     \# hello perl}
\end{Highlighting}
\end{Shaded}

Zero runtime cost (parse-time desugaring). Binds looser than
\texttt{\textbar{}\textbar{}}, tighter than \texttt{?:}.

\section{\texorpdfstring{\texttt{thread}}{thread}}\label{thread}

Thread-first macro --- chain stages where the threaded value is injected
as the \textbf{first} argument (like Clojure\textquotesingle s
\texttt{-\textgreater{}}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\textasciitilde{}\textgreater{} @data grep \{ \_ \textgreater{} 5 \} map \{ \_ * 2 \} sort \{ $\_0 \textless{}=\textgreater{} $\_1 \} |\textgreater{} join "," |\textgreater{} p}
\NormalTok{\textasciitilde{}\textgreater{} " hello " tm uc rv lc ufc sc cc kc tj p  \# short aliases}
\NormalTok{fn div = \_0 / \_1}
\NormalTok{\textasciitilde{}\textgreater{} 10 div(2) p                               \# div(10, 2) = 5}
\NormalTok{\textasciitilde{}\textgreater{} 10 div(\_, 2) p                           \# explicit \_ position: div(10, 2) = 5}
\end{Highlighting}
\end{Shaded}

Spellings: \texttt{\textasciitilde{}\textgreater{}}, \texttt{thread},
\texttt{t}. Stages: bare function (\texttt{uc}, \texttt{tm}, \ldots),
function with block (\texttt{map\ \{\ …\ \}}, \texttt{grep\ \{\ …\ \}}),
\texttt{name(args)} call where \texttt{\_} is the threaded-value
placeholder, or \texttt{\textgreater{}\{\}} anonymous block.
\texttt{\textbar{}\textgreater{}} terminates the macro.

\section{\texorpdfstring{\texttt{-\textgreater{}\textgreater{}}}{-\textgreater\textgreater{}}}\label{section-1}

Thread-last macro --- chain stages where the threaded value is injected
as the \textbf{last} argument (like Clojure\textquotesingle s
\texttt{-\textgreater{}\textgreater{}}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn div = \_0 / \_1}
\NormalTok{\textasciitilde{}\textgreater{}\textgreater{} 10 div(2) p                              \# div(2, 10) = 0.2}
\NormalTok{{-}\textgreater{}\textgreater{} 10 div(\_, 2) p                          \# explicit \_ overrides: div(10, 2) = 5}

\NormalTok{\# Thread{-}last is useful for list{-}consuming functions:}
\NormalTok{fn first\_n \{ @\_[0..$\_[{-}1]{-}1] \}              \# first\_n(list, n)}
\NormalTok{\textasciitilde{}\textgreater{}\textgreater{} (1,2,3,4,5) first\_n(3) p                 \# first\_n(1,2,3,4,5, 3) = (1,2,3)}
\end{Highlighting}
\end{Shaded}

Spellings: \texttt{\textasciitilde{}\textgreater{}\textgreater{}},
\texttt{-\textgreater{}\textgreater{}}. The explicit \texttt{\_}
placeholder always takes precedence.

\section{\texorpdfstring{\texttt{\textasciitilde{}s\textgreater{}}}{\textasciitilde s\textgreater{}}}\label{s}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\textasciitilde{}s\textgreater{} [1, 2, 3, 4, 5] map \{ \_ * 10 \} map \{ \_ + 1 \}}
\NormalTok{\textasciitilde{}s\textgreater{} @lines map \{ json\_decode \} grep \{ \_{-}\textgreater{}\{ok\} \} map \{ \_{-}\textgreater{}\{val\} \}}
\NormalTok{\textasciitilde{}s\textgreater{} gen \{ yield\_lines "huge.log" \} map \{ parse \} grep \{ /ERROR/ \}}
\end{Highlighting}
\end{Shaded}

Use \texttt{\textasciitilde{}s\textgreater{}} when stages have differing
latencies (I/O + CPU mix) so faster workers can pull ahead. Output order
is non-deterministic. The macro\textquotesingle s final value is the
count of items the last stage emitted.
\texttt{\textasciitilde{}s\textgreater{}\textgreater{}} is the
thread-last variant.

See \texttt{\textasciitilde{}p\textgreater{}} for chunk-parallel (vs
per-item) execution and \texttt{par\_pipeline} for the verbose builder
form.

\section{\texorpdfstring{\texttt{\textasciitilde{}p\textgreater{}}}{\textasciitilde p\textgreater{}}}\label{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
\texttt{par\_reduce\ \{\ stage1\ \textbar{}\textgreater{}\ stage2\ \textbar{}\textgreater{}\ ...\ \}\ SRC}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\textasciitilde{}p\textgreater{} c("**.rs") letters freq                              \# histogram across all .rs}
\NormalTok{\textasciitilde{}p\textgreater{} @big map \{ \_ * 2 \} sum                               \# parallel map+sum}
\NormalTok{\textasciitilde{}p\textgreater{} $huge letters freq ||\textgreater{} values |\textgreater{} sum                 \# boundary: terse}
\NormalTok{\textasciitilde{}p\textgreater{} $huge letters freq |then| values |\textgreater{} sum              \# boundary: english}
\end{Highlighting}
\end{Shaded}

The auto-merger picks a strategy by inspecting the first
chunk\textquotesingle s result type: hash-of-numbers merges key-wise
with \texttt{+} (canonical histogram), numeric scalars sum, arrays
concat, strings concat. Use \texttt{\textbar{}\textbar{}\textgreater{}}
or \texttt{\textbar{}then\textbar{}} to switch back to sequential
\texttt{\textasciitilde{}\textgreater{}} mode for stages that operate on
the merged whole. \texttt{\textbar{}\textgreater{}} also terminates a
\texttt{\textasciitilde{}p\textgreater{}} macro.
\texttt{\textasciitilde{}p\textgreater{}\textgreater{}} is the
thread-last variant.

\section{\texorpdfstring{\texttt{par}}{par}}\label{par}

Generic parallel-chunk thread-stage --- only valid inside
\texttt{\textasciitilde{}\textgreater{}}/\texttt{\textasciitilde{}\textgreater{}\textgreater{}}.
Splits the threaded value into chunks, runs \texttt{BLOCK} on each chunk
in parallel, and flattens chunk outputs into a single list.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = \textasciitilde{}\textgreater{} "Hello, World 123" par \{ letters \}    \# H e l l o W o r l d}
\NormalTok{\textasciitilde{}\textgreater{} @huge par \{ map \{ \_ ** 2 \} |\textgreater{} sum \} |\textgreater{} sum p   \# parallel sum{-}of{-}squares}
\end{Highlighting}
\end{Shaded}

Each chunk gets a fresh sub-VM with the chunk bound to \texttt{\_} and
\texttt{\$\_{[}0{]}}. List-returning ops keep their values; the runtime
auto-flattens. Use \texttt{par\_reduce} when you need a final merge step
rather than flat concat. \texttt{par\ \{\ …\ \}} is *only* a
thread-stage; calling it as a top-level expression is an undefined-sub
error.

\section{\texorpdfstring{\texttt{par\_reduce}}{par\_reduce}}\label{par_reduce}

Chunk-extract-merge thread-stage. The single-block form runs
\texttt{extract} per chunk and auto-merges results by type
(hash\textless num\textgreater→key-wise add, number→sum, array→concat,
string→concat). The two-block form binds \texttt{\$a}/\texttt{\$b} in
the explicit reducer.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\textasciitilde{}\textgreater{} "abc def abc" par\_reduce \{ letters |\textgreater{} freq \}      \# canonical histogram merge}
\NormalTok{\textasciitilde{}\textgreater{} @nums par\_reduce \{ sum \}                          \# parallel sum}
\NormalTok{\textasciitilde{}\textgreater{} "abcdefgh" par\_reduce \{ length(\_) \} \{ $a + $b \}   \# explicit pairwise reducer}
\end{Highlighting}
\end{Shaded}

Below the chunk threshold the runtime falls back to single-chunk eval;
the result must still match the bare extract block\textquotesingle s
output. Multi-chunk paths require the merger (auto or explicit) to be
associative and commutative for correct results.

\section{\texorpdfstring{\texttt{\textbar{}\textbar{}\textgreater{}}}{\textbar\textbar\textgreater{}}}\label{section-2}

Boundary marker that terminates the chunk-parallel section of a
\texttt{\textasciitilde{}p\textgreater{}} macro and switches the merged
result into a sequential \texttt{\textasciitilde{}\textgreater{}}
continuation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\textasciitilde{}p\textgreater{} "abc def abc" letters freq ||\textgreater{} values |\textgreater{} sum     \# 9}
\NormalTok{\textasciitilde{}p\textgreater{} "abc def abc" letters freq |then| values |\textgreater{} sum  \# 9 — readable form}
\NormalTok{\textasciitilde{}p\textgreater{} @data map \{ \_ * 2 \} sum ||\textgreater{} sqrt p               \# parallel sum, sequential sqrt}
\end{Highlighting}
\end{Shaded}

Both spellings are byte-equivalent;
\texttt{\textbar{}\textbar{}\textgreater{}} is terse,
\texttt{\textbar{}then\textbar{}} reads in English. Use either when you
need a post-merge stage that operates on the whole reduced value rather
than per-chunk. \texttt{\textbar{}\textgreater{}} also terminates a
\texttt{\textasciitilde{}p\textgreater{}} macro.

\section{\texorpdfstring{\texttt{pipeline}}{pipeline}}\label{pipeline}

\texttt{pipeline(@list)} --- wrap a list (or iterator) in a lazy
pipeline object supporting chained \texttt{-\textgreater{}map},
\texttt{-\textgreater{}filter}, \texttt{-\textgreater{}take},
\texttt{-\textgreater{}skip}, \texttt{-\textgreater{}flat\_map},
\texttt{-\textgreater{}tap}, and other transforms that execute zero work
until a terminal method is called.

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 \texttt{-\textgreater{}collect} (materialize to list),
\texttt{-\textgreater{}reduce\ \{\ ...\ \}} (fold),
\texttt{-\textgreater{}for\_each\ \{\ ...\ \}} (side-effect iteration),
and \texttt{-\textgreater{}count}. Pipelines compose naturally with
stryke\textquotesingle s \texttt{\textbar{}\textgreater{}} operator: you
can feed \texttt{pipeline(...)} output into further
\texttt{\textbar{}\textgreater{}} stages or vice versa. Use
\texttt{pipeline} when you want explicit method-chaining style rather
than the flat \texttt{\textbar{}\textgreater{}} pipe syntax --- both
compile to the same lazy evaluation engine.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @out = pipeline(@data)}
\NormalTok{  {-}\textgreater{}filter \{ \_ \textgreater{} 0 \}}
\NormalTok{  {-}\textgreater{}map \{ \_ * 2 \}}
\NormalTok{  {-}\textgreater{}take(10)}
\NormalTok{  {-}\textgreater{}collect}

\NormalTok{pipeline(1:1\_000\_000)}
\NormalTok{  {-}\textgreater{}filter \{ \_ \% 3 == 0 \}}
\NormalTok{  {-}\textgreater{}map \{ \_ ** 2 \}}
\NormalTok{  {-}\textgreater{}take(5)}
\NormalTok{  {-}\textgreater{}for\_each \{ p \_ \}                \# 9 36 81 144 225}

\NormalTok{my $sum = pipeline(@scores)}
\NormalTok{  {-}\textgreater{}filter \{ \_ \textgreater{}= 60 \}}
\NormalTok{  {-}\textgreater{}reduce \{ $\_0 + $\_1 \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_pipeline}}{par\_pipeline}}\label{par_pipeline}

\texttt{par\_pipeline(source\ =\textgreater{}\ \textbackslash{}@data,\ stages\ =\textgreater{}\ {[}...{]},\ workers\ =\textgreater{}\ N)}
--- build a multi-stage parallel pipeline where each
stage\textquotesingle s map/filter block runs concurrently across N
worker threads.

Unlike \texttt{pmap} which parallelizes a single transform,
\texttt{par\_pipeline} 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 \texttt{workers} parameter defaults to the number
of logical CPUs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @results = par\_pipeline(}
\NormalTok{    source  =\textgreater{} \textbackslash{}@raw\_records,}
\NormalTok{    stages  =\textgreater{} [}
\NormalTok{        \{ name =\textgreater{} "parse",     map =\textgreater{} fn \{ json\_decode \} \},}
\NormalTok{        \{ name =\textgreater{} "transform", map =\textgreater{} fn \{ enrich \} \},}
\NormalTok{        \{ name =\textgreater{} "validate",  filter =\textgreater{} fn \{ \_{-}\textgreater{}\{valid\} \} \},}
\NormalTok{    ],}
\NormalTok{    workers =\textgreater{} 8,}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_pipeline\_stream}}{par\_pipeline\_stream}}\label{par_pipeline_stream}

\texttt{par\_pipeline\_stream(source\ =\textgreater{}\ ...,\ stages\ =\textgreater{}\ {[}...{]},\ workers\ =\textgreater{}\ N)}
--- streaming variant of \texttt{par\_pipeline} that connects stages via
bounded \texttt{pchannel} queues instead of materializing intermediate
arrays.

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 \texttt{ordered\ =\textgreater{}\ 1} to reorder
them to match input order at the cost of buffering.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{par\_pipeline\_stream(}
\NormalTok{    source  =\textgreater{} fn \{ while (my $line = \textless{}STDIN\textgreater{}) \{ yield $line \} \},}
\NormalTok{    stages  =\textgreater{} [}
\NormalTok{        \{ name =\textgreater{} "parse", map =\textgreater{} fn \{ json\_decode \} \},}
\NormalTok{        \{ name =\textgreater{} "score", map =\textgreater{} fn \{ compute\_score \} \},}
\NormalTok{    ],}
\NormalTok{    workers =\textgreater{} 4,}
\NormalTok{    on\_item =\textgreater{} fn \{ p \_ \},           \# process results as they arrive}
\NormalTok{)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collect}}{collect}}\label{collect}

\texttt{collect\ ITERATOR} --- materialize a lazy iterator or pipeline
into a concrete list.

Pipeline stages in stryke are lazy: chaining
\texttt{\textbar{}\textgreater{}\ map\ \{...\}\ \textbar{}\textgreater{}\ grep\ \{...\}}
builds up a deferred computation without consuming any elements. Calling
\texttt{collect} 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 \texttt{collect}, the iterator
is consumed element-by-element by \texttt{e}, \texttt{take}, or other
streaming sinks.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @out = range(1,5) |\textgreater{} map \{ \_ * 2 \} |\textgreater{} collect}
\NormalTok{gen \{ yield \_ for 1:3 \} |\textgreater{} collect |\textgreater{} e p}
\NormalTok{my @data = stdin |\textgreater{} grep /INFO/ |\textgreater{} collect}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-streaming-iterators}
\chapter{Streaming Iterators}\label{streaming-iterators}

24 topics

\section{\texorpdfstring{\texttt{maps}}{maps}}\label{maps}

\texttt{maps\ \{\ BLOCK\ \}\ LIST} --- the lazy, streaming counterpart
of \texttt{map}. Instead of materializing the entire output list,
\texttt{maps} returns a pull iterator that evaluates the block on demand
as downstream consumers request values. This makes it ideal for
\texttt{\textbar{}\textgreater{}} pipeline chains, especially when
combined with \texttt{take}, \texttt{greps}, or \texttt{collect}. Use
\texttt{maps} over \texttt{map} when working with large ranges, infinite
sequences, or when you want to short-circuit processing early with
\texttt{take}. Memory usage is constant regardless of input size.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} maps \{ \_ * 3 \} |\textgreater{} take 4 |\textgreater{} e p}
\NormalTok{\# 3 6 9 12}
\NormalTok{1:1\_000\_000 |\textgreater{} maps \{ \_ ** 2 \} |\textgreater{} greps \{ \_ \textgreater{} 100 \} |\textgreater{} take 3 |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{greps}}{greps}}\label{greps}

\texttt{greps\ \{\ BLOCK\ \}\ LIST} --- the lazy, streaming counterpart
of \texttt{grep}. Returns a pull iterator that only evaluates the
predicate as elements are requested downstream. This is the preferred
filtering function in \texttt{\textbar{}\textgreater{}} pipelines
because it avoids materializing intermediate lists. Combine with
\texttt{take} to short-circuit early, or with \texttt{maps} and
\texttt{collect} for full lazy pipelines. The block receives \texttt{\_}
just like \texttt{grep}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:100 |\textgreater{} greps \{ \_ \% 7 == 0 \} |\textgreater{} take 3 |\textgreater{} e p}
\NormalTok{\# 7 14 21}
\NormalTok{@lines |\textgreater{} greps \{ /ERROR/ \} |\textgreater{} maps \{ tm \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter}}{filter}}\label{filter}

\texttt{filter} (alias \texttt{fi}) \texttt{\{\ BLOCK\ \}\ LIST} ---
stryke-native lazy filter that returns a pull iterator, functionally
identical to \texttt{greps} but named for familiarity with Rust/Ruby/JS
conventions. Use \texttt{filter} or \texttt{greps} interchangeably in
\texttt{\textbar{}\textgreater{}} chains; both are streaming and both
set \texttt{\_} in the block. The result must be consumed with
\texttt{collect}, \texttt{e\ p}, \texttt{foreach}, or another terminal.
Prefer \texttt{filter} when writing stryke-idiomatic code; prefer
\texttt{grep}/\texttt{greps} when porting from Perl.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @big = 1:1000 |\textgreater{} filter \{ \_ \textgreater{} 990 \} |\textgreater{} collect}
\NormalTok{@big |\textgreater{} e p   \# 991 992 993 994 995 996 997 998 999 1000}
\NormalTok{1:50 |\textgreater{} fi \{ \_ \% 2 \} |\textgreater{} take 5 |\textgreater{} e p   \# 1 3 5 7 9}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tap}}{tap}}\label{tap}

\texttt{tap\ \{\ BLOCK\ \}\ LIST} --- execute a side-effecting block for
each element, then pass the element through unchanged.

The return value of the block is ignored; the original element is always
forwarded to the next pipeline stage. This makes \texttt{tap} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:5 |\textgreater{} tap \{ log\_debug "saw: $\_" \} |\textgreater{} map \{ \_ * 2 \} |\textgreater{} e p}
\NormalTok{@files |\textgreater{} tap \{ p "processing: $\_" \} |\textgreater{} map slurp |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peek}}{peek}}\label{peek}

\texttt{peek\ ITERATOR} --- inspect the next element of an iterator
without consuming it.

The peeked value is buffered internally so that the next call to
\texttt{-\textgreater{}next} or pipeline pull returns the same element.
This is useful for lookahead parsing, conditional branching on the next
value, or implementing \texttt{take\_while}-style logic manually.
Calling \texttt{peek} multiple times without advancing the iterator
returns the same value each time. Works with any stryke iterator
including \texttt{gen}, \texttt{range}, \texttt{stdin}, and pipeline
results.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $g = gen \{ yield \_ for 1:5 \}}
\NormalTok{p peek $g                             \# 1 (not consumed)}
\NormalTok{p $g{-}\textgreater{}next                            \# 1}
\NormalTok{p peek $g                             \# 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tee}}{tee}}\label{tee}

\texttt{tee\ FILE,\ ITERATOR} --- write each element to a file as a side
effect while passing it through the pipeline.

Every element that flows through \texttt{tee} 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
\texttt{tee} command, useful for auditing or logging intermediate
pipeline results to disk.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} tee "/tmp/log.txt" |\textgreater{} map \{ \_ * 2 \} |\textgreater{} e p}
\NormalTok{stdin |\textgreater{} tee "/tmp/raw.log" |\textgreater{} grep /ERROR/ |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{take}}{take}}\label{take}

\texttt{take\ N,\ LIST} / \texttt{head\ N,\ LIST} /
\texttt{hd\ N,\ LIST} --- return at most the first N elements.

In streaming mode, \texttt{take} 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
\texttt{range(1,\ 1\_000\_000)\ \textbar{}\textgreater{}\ take\ 5}
without allocating a million-element list. If the source has fewer than
N elements, all of them are returned. The \texttt{head} and \texttt{hd}
aliases mirror Unix \texttt{head} semantics.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:100 |\textgreater{} take 5 |\textgreater{} e p               \# 1 2 3 4 5}
\NormalTok{my @top = hd 3, @sorted}
\NormalTok{stdin |\textgreater{} hd 10 |\textgreater{} e p                 \# first 10 lines}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tail}}{tail}}\label{tail}

\texttt{tail\ N,\ @list} --- returns the last N elements of the list. If
N exceeds the list length, the entire list is returned. The alias
\texttt{tl} is also available. This is the complement of
\texttt{head}/\texttt{take}. In stryke, it works both as a function call
and in \texttt{\textbar{}\textgreater{}} pipelines.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @t = tail 2, 1:5}
\NormalTok{@t |\textgreater{} e p   \# 4 5}
\NormalTok{1:100 |\textgreater{} tl 3 |\textgreater{} e p  \# 98 99 100}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drop}}{drop}}\label{drop}

\texttt{drop\ N,\ LIST} / \texttt{skip\ N,\ LIST} /
\texttt{drp\ N,\ LIST} --- skip the first N elements and return the
rest.

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 \texttt{skip} and
\texttt{drp} aliases exist for readability in different contexts --- all
three compile to the same internal op.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} drop 3 |\textgreater{} e p                \# 4 5 6 7 8 9 10}
\NormalTok{my @rest = drp 2, @data}
\NormalTok{stdin |\textgreater{} skip 1 |\textgreater{} e p                \# skip header line}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{take\_while}}{take\_while}}\label{take_while}

\texttt{take\_while\ \{\ COND\ \}\ LIST} --- emit leading elements while
the predicate returns true, then stop.

The block receives each element as \texttt{\_}. 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 \texttt{take\_while} efficient on infinite
iterators and large streams. It is the complement of
\texttt{drop\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} take\_while \{ \_ \textless{} 5 \} |\textgreater{} e p \# 1 2 3 4}
\NormalTok{stdin |\textgreater{} take\_while \{ !/\^{}END/ \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drop\_while}}{drop\_while}}\label{drop_while}

\texttt{drop\_while\ \{\ COND\ \}\ LIST} --- skip leading elements while
the predicate returns true, then emit everything after.

The block receives each element as \texttt{\_}. 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} drop\_while \{ \_ \textless{} 5 \} |\textgreater{} e p \# 5 6 7 8 9 10}
\NormalTok{@log |\textgreater{} drop\_while \{ /\^{} \#/ \} |\textgreater{} e p    \# skip comment header}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reject}}{reject}}\label{reject}

\texttt{reject\ \{\ BLOCK\ \}\ LIST} --- stryke-native streaming inverse
of \texttt{filter}/\texttt{greps}. It keeps only the elements for which
the block returns false. This reads more naturally than
\texttt{filter\ \{\ !(...)\ \}} when the condition describes what you
want to exclude rather than what you want to keep. Like \texttt{filter}
and \texttt{greps}, it returns a lazy iterator suitable for
\texttt{\textbar{}\textgreater{}} chains. The block receives \texttt{\_}
as the current element.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} reject \{ \_ \% 3 == 0 \} |\textgreater{} e p}
\NormalTok{\# 1 2 4 5 7 8 10}
\NormalTok{@files |\textgreater{} reject \{ /\textbackslash{}.bak$/ \} |\textgreater{} e p   \# skip backups}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compact}}{compact}}\label{compact}

\texttt{compact} (alias \texttt{cpt}) --- stryke-native streaming
operator that removes \texttt{undef} 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
\texttt{greps\ \{\ defined(\_)\ \&\&\ \_\ ne\ ""\ \}} but more concise
and faster because the check is inlined in Rust. Numeric zero and the
string \texttt{"0"} are preserved since they are defined and non-empty.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @raw = (1, undef, "", 2, undef, 3)}
\NormalTok{@raw |\textgreater{} compact |\textgreater{} e p   \# 1 2 3}
\NormalTok{split(/,/, "a,,b,,,c") |\textgreater{} cpt |\textgreater{} e p   \# a b c}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{concat}}{concat}}\label{concat}

\texttt{concat} (alias \texttt{chain}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:3}
\NormalTok{my @b = 7:9}
\NormalTok{concat(\textbackslash{}@a, \textbackslash{}@b) |\textgreater{} e p   \# 1 2 3 7 8 9}
\NormalTok{my @c = ("x")}
\NormalTok{concat(\textbackslash{}@a, \textbackslash{}@b, \textbackslash{}@c) |\textgreater{} maps \{ uc \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{enumerate}}{enumerate}}\label{enumerate}

\texttt{enumerate\ ITERATOR} / \texttt{en\ ITERATOR} --- yield
\texttt{{[}\$index,\ \$item{]}} pairs from a streaming iterator.

Each element is wrapped as \texttt{{[}\$index,\ \$item{]}} where the
index starts at 0 and increments for each element. Unlike
\texttt{with\_index} which returns \texttt{{[}item,\ index{]}},
\texttt{enumerate} uses the Rust/Python convention of
\texttt{{[}index,\ item{]}}. This is a streaming operation: the index
counter is maintained lazily as elements flow through the pipeline.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{stdin |\textgreater{} en |\textgreater{} e \{ p "\_{-}\textgreater{}[0]: \_{-}\textgreater{}[1]" \}}
\NormalTok{1:5 |\textgreater{} en |\textgreater{} e \{ p "\_{-}\textgreater{}[0]: \_{-}\textgreater{}[1]" \}}
\NormalTok{@lines |\textgreater{} en |\textgreater{} grep \{ \_{-}\textgreater{}[0] \textless{} 10 \} |\textgreater{} e \{ p \_{-}\textgreater{}[1] \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chunk}}{chunk}}\label{chunk}

\texttt{chunk\ N,\ ITERATOR} / \texttt{chk\ N,\ ITERATOR} --- group
elements into N-sized arrayrefs as they stream through.

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 \texttt{chunk} for batching work (e.g., bulk database
inserts) or formatting output into rows.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:9 |\textgreater{} chk 3 |\textgreater{} e \{ p join ",", @\_ \}}
\NormalTok{\# 1,2,3  4,5,6  7,8,9}
\NormalTok{stdin |\textgreater{} chk 100 |\textgreater{} e \{ bulk\_insert(@\_) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dedup}}{dedup}}\label{dedup}

\texttt{dedup\ ITERATOR} / \texttt{dup\ ITERATOR} --- drop consecutive
duplicate elements from a stream.

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 \texttt{distinct}
instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1,1,2,2,3,1,1 |\textgreater{} dedup |\textgreater{} e p        \# 1 2 3 1}
\NormalTok{@sorted |\textgreater{} dedup |\textgreater{} e p              \# like uniq(1)}
\NormalTok{stdin |\textgreater{} dedup |\textgreater{} e p                 \# collapse repeated lines}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{distinct}}{distinct}}\label{distinct}

\texttt{distinct\ LIST} --- remove duplicate elements, preserving
first-occurrence order (alias for \texttt{uniq}).

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 \texttt{distinct} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @u = distinct(3,1,2,1,3)           \# (3,1,2)}
\NormalTok{1,2,2,3,3,3 |\textgreater{} distinct |\textgreater{} e p        \# 1 2 3}
\NormalTok{stdin |\textgreater{} distinct |\textgreater{} e p              \# unique lines}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flatten}}{flatten}}\label{flatten}

\texttt{flatten\ LIST} / \texttt{fl\ LIST} --- recursively flatten
nested arrayrefs into a single flat list.

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
(\texttt{\textbar{}\textgreater{}\ fl}) it streams element-by-element,
so you can chain it with \texttt{map}, \texttt{grep}, or \texttt{take}
without materializing the entire intermediate list. The \texttt{fl}
alias keeps pipeline chains concise.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @flat = flatten([1,[2,3]],[4])     \# (1,2,3,4)}
\NormalTok{[1,[2,[3,4]]] |\textgreater{} fl |\textgreater{} e p            \# 1 2 3 4}
\NormalTok{@nested |\textgreater{} fl |\textgreater{} grep \{ \_ \textgreater{} 0 \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{with\_index}}{with\_index}}\label{with_index}

\texttt{with\_index\ LIST} / \texttt{wi\ LIST} --- pair each element
with its 0-based index as \texttt{{[}\$item,\ \$index{]}}.

Each element is wrapped in a two-element arrayref where
\texttt{\_-\textgreater{}{[}0{]}} is the original value and
\texttt{\_-\textgreater{}{[}1{]}} 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 \texttt{{[}item,\ index{]}}, which
differs from \texttt{enumerate} which yields
\texttt{{[}index,\ item{]}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{qw(a b c) |\textgreater{} wi |\textgreater{} e \{ p "\_{-}\textgreater{}[1]: \_{-}\textgreater{}[0]" \}}
\NormalTok{\# 0: a  1: b  2: c}
\NormalTok{@data |\textgreater{} wi |\textgreater{} grep \{ \_{-}\textgreater{}[1] \% 2 == 0 \} |\textgreater{} e \{ p \_{-}\textgreater{}[0] \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_or}}{first\_or}}\label{first_or}

\texttt{first\_or\ DEFAULT,\ LIST} --- return the first element of the
list, or DEFAULT if the list is empty.

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 \texttt{grep} or \texttt{map} pipeline
where you need a safe fallback instead of \texttt{undef} when no match
is found.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $v = first\_or 0, @maybe\_empty}
\NormalTok{my $x = grep \{ \_ \textgreater{} 99 \} @nums |\textgreater{} first\_or {-}1}
\NormalTok{stdin |\textgreater{} grep /\^{}ERROR/ |\textgreater{} first\_or "(none)" |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range}}{range}}\label{range}

\texttt{range(START,\ END\ {[},\ STEP{]})} --- create a lazy integer
iterator from START to END with an optional step.

The range is inclusive on both ends. When START \textgreater{} 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
\texttt{range(1,\ 1\_000\_000)} as cheap to create as
\texttt{range(1,\ 5)}. Combine with \texttt{\textbar{}\textgreater{}} to
feed into streaming pipelines.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{range(1, 5) |\textgreater{} e p                    \# 1 2 3 4 5}
\NormalTok{range(5, 1) |\textgreater{} e p                    \# 5 4 3 2 1}
\NormalTok{range(0, 10, 2) |\textgreater{} e p                \# 0 2 4 6 8 10}
\NormalTok{range(10, 0, {-}2) |\textgreater{} e p               \# 10 8 6 4 2 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stdin}}{stdin}}\label{stdin}

\texttt{stdin} --- return a streaming iterator over lines read from
standard input.

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 \texttt{stdin} with \texttt{take}, \texttt{grep}, or
\texttt{first\_or} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{stdin |\textgreater{} grep /error/i |\textgreater{} e p}
\NormalTok{stdin |\textgreater{} take 5 |\textgreater{} e p}
\NormalTok{stdin |\textgreater{} en |\textgreater{} e \{ p "\_{-}\textgreater{}[0]: \_{-}\textgreater{}[1]" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth}}{nth}}\label{nth}

\texttt{nth\ N,\ LIST} --- return the Nth element using 0-based
indexing.

When used in a pipeline, \texttt{nth} 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
\texttt{\$list{[}N{]}} but works as a function call for pipeline
composition. Returns \texttt{undef} if the list has fewer than N+1
elements.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $third = nth 2, @data}
\NormalTok{1:10 |\textgreater{} nth 4 |\textgreater{} p                   \# 5}
\NormalTok{stdin |\textgreater{} nth 0 |\textgreater{} p                   \# first line}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-list-operations}
\chapter{List Operations}\label{list-operations}

62 topics

\section{\texorpdfstring{\texttt{map}}{map}}\label{map}

\texttt{map\ BLOCK\ LIST} --- evaluates the block for each element of
the list, setting \texttt{\_} to the current element, and returns a new
list of all the block\textquotesingle s return values. This is the eager
version: it consumes the entire input list and produces the entire
output list before returning. Use \texttt{map} when you need the full
result array or when the input is small. For large or infinite
sequences, prefer \texttt{maps} (the streaming variant). The block can
return zero, one, or multiple values per element, making \texttt{map}
useful for both transformation and flattening. Use
\texttt{\{\ \textbar{}\$var\textbar{}\ body\ \}} to name the block
parameter instead of \texttt{\_}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @sq = map \{ \_ ** 2 \} 1:5}
\NormalTok{@sq |\textgreater{} e p   \# 1 4 9 16 25}
\NormalTok{map \{ |$n| $n * $n \}, 1:5   \# named param}
\NormalTok{my @pairs = map \{ (\_, \_ * 10) \} 1:3}
\NormalTok{@pairs |\textgreater{} e p   \# 1 10 2 20 3 30}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grep}}{grep}}\label{grep}

\texttt{grep\ \{\ BLOCK\ \}\ LIST} --- filters the list, returning only
elements for which the block evaluates to true. The current element is
available as \texttt{\_}. This is the eager version: it processes the
entire list and returns a new list. It is Perl-compatible and works
exactly like Perl\textquotesingle s builtin \texttt{grep}. For
streaming/lazy filtering in \texttt{\textbar{}\textgreater{}} pipelines,
use \texttt{greps} or \texttt{filter} instead. Use
\texttt{\{\ \textbar{}\$var\textbar{}\ body\ \}} to name the block
parameter instead of \texttt{\_}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @evens = grep \{ \_ \% 2 == 0 \} 1:10}
\NormalTok{@evens |\textgreater{} e p   \# 2 4 6 8 10}
\NormalTok{grep \{ |$x| $x \textgreater{} 3 \}, 1:6   \# named param}
\NormalTok{my @long = grep \{ length(\_) \textgreater{} 3 \} @words}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sort}}{sort}}\label{sort}

\texttt{sort\ {[}BLOCK{]}\ LIST} --- returns a new list sorted in
ascending order. Without a block, \texttt{sort} compares elements as
strings (lexicographic). Pass a comparator block using \texttt{\$\_0}
and \texttt{\$\_1} (stryke style) or \texttt{\$a} and \texttt{\$b}
(classic Perl) to control ordering: use
\texttt{\textless{}=\textgreater{}} for numeric and \texttt{cmp} 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
\texttt{\{\ \textbar{}\$x,\ \$y\textbar{}\ body\ \}} to name the two
comparator params. Works naturally in \texttt{\textbar{}\textgreater{}}
pipelines.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @nums = (3, 1, 4, 1, 5)}
\NormalTok{my @asc = sort \{ $\_0 \textless{}=\textgreater{} $\_1 \} @nums}
\NormalTok{@asc |\textgreater{} e p   \# 1 1 3 4 5}
\NormalTok{sort \{ |$x, $y| $y \textless{}=\textgreater{} $x \}, @nums   \# named params}
\NormalTok{my @desc = sort \{ $\_1 \textless{}=\textgreater{} $\_0 \} @nums}
\NormalTok{@desc |\textgreater{} e p  \# 5 4 3 1 1}
\NormalTok{@nums |\textgreater{} sort |\textgreater{} e p   \# string sort in pipeline}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse}}{reverse}}\label{reverse}

\texttt{reverse\ LIST} --- in list context, return the elements in
reverse order; in scalar context, reverse the characters of a string.

The dual nature of \texttt{reverse} is context-dependent:
\texttt{reverse\ @array} flips element order, while
\texttt{scalar\ reverse\ \$string} (or just \texttt{reverse\ \$string}
in scalar context) reverses character order. In stryke, the string form
is Unicode-aware, correctly reversing multi-byte characters rather than
individual bytes. In \texttt{\textbar{}\textgreater{}} pipelines, use
the \texttt{t\ rev} shorthand for a concise streaming string reverse.
\texttt{reverse} does not modify the original --- it always returns a
new list or string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p reverse "hello"       \# olleh}
\NormalTok{my @r = reverse 1:5   \# (5,4,3,2,1)}
\NormalTok{@r |\textgreater{} e p               \# 5 4 3 2 1}
\NormalTok{"abc" |\textgreater{} t rev |\textgreater{} p     \# cba}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reduce}}{reduce}}\label{reduce}

\texttt{reduce\ \{\ \$\_0\ OP\ \$\_1\ \}\ @list} --- performs a
sequential left fold over the list. The first two elements are passed as
\texttt{\$\_0} and \texttt{\$\_1} to the block; the result becomes
\texttt{\$\_0} for the next iteration. The traditional
\texttt{\$a}/\texttt{\$b} names are also supported for Perl
compatibility. Use
\texttt{\{\ \textbar{}\$acc,\ \$val\textbar{}\ body\ \}} to name the two
params. Returns \texttt{undef} for an empty list and the single element
for a one-element list. For a fold with an explicit initial value, see
\texttt{fold}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $fac = reduce \{ $\_0 * $\_1 \} 1:6}
\NormalTok{p $fac   \# 720}
\NormalTok{reduce \{ |$acc, $val| $acc + $val \}, 1:10   \# 55 (named params)}
\NormalTok{my $longest = reduce \{ length($\_0) \textgreater{} length($\_1) ? $\_0 : $\_1 \} @words}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fold}}{fold}}\label{fold}

\texttt{fold\ \{\ \$\_0\ OP\ \$\_1\ \}\ INIT,\ @list} --- left fold with
an explicit initial accumulator value. The initial value is passed as
the first \texttt{\$\_0}, and each list element arrives as
\texttt{\$\_1}. Unlike \texttt{reduce}, \texttt{fold} never returns
\texttt{undef} for an empty list --- it returns the initial value
instead. Both \texttt{\$a}/\texttt{\$b} and
\texttt{\$\_0}/\texttt{\$\_1} are supported in the block. Use
\texttt{fold} when you need a guaranteed starting point for the
accumulation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $total = fold \{ $\_0 + $\_1 \} 100, 1:5}
\NormalTok{p $total   \# 115}
\NormalTok{my $csv = fold \{ "$\_0,$\_1" \} "", @fields}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reductions}}{reductions}}\label{reductions}

\texttt{reductions\ \{\ \$\_0\ OP\ \$\_1\ \}\ @list} --- 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 \texttt{\$\_0}/\texttt{\$\_1} and
\texttt{\$a}/\texttt{\$b} naming conventions are supported.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @pfx = reductions \{ $\_0 + $\_1 \} 1:4}
\NormalTok{@pfx |\textgreater{} e p   \# 1 3 6 10}
\NormalTok{1:5 |\textgreater{} reductions \{ $\_0 * $\_1 \} |\textgreater{} e p  \# 1 2 6 24 120}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{all}}{all}}\label{all}

\texttt{all\ \{\ COND\ \}\ @list} --- returns true (1) if every element
in the list satisfies the predicate, false ("") otherwise. The block
receives each element as \texttt{\_} and should return a boolean.
Short-circuits on the first failing element, so it never evaluates more
than necessary. Works with \texttt{\textbar{}\textgreater{}} pipelines
and accepts bare lists or array variables.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @nums = 2, 4, 6, 8}
\NormalTok{p all \{ \_ \% 2 == 0 \} @nums   \# 1}
\NormalTok{1:100 |\textgreater{} all \{ \_ \textgreater{} 0 \} |\textgreater{} p  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{any}}{any}}\label{any}

\texttt{any\ \{\ COND\ \}\ @list} --- returns true (1) if at least one
element satisfies the predicate, false ("") if none do. The block
receives each element as \texttt{\_}. Short-circuits on the first match,
making it efficient even on large lists. \texttt{any} is a stryke global
builtin and can be used in \texttt{\textbar{}\textgreater{}} pipelines.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @vals = 1, 3, 5, 8}
\NormalTok{p any \{ \_ \textgreater{} 7 \} @vals   \# 1}
\NormalTok{1:1000 |\textgreater{} any \{ \_ == 42 \} |\textgreater{} p  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{none}}{none}}\label{none}

\texttt{none\ \{\ COND\ \}\ @list} --- returns true (1) if no element
satisfies the predicate, false ("") if any element matches. Logically
equivalent to \texttt{!any\ \{\ COND\ \}\ @list} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @words = ("cat", "dog", "bird")}
\NormalTok{p none \{ /z/ \} @words   \# 1}
\NormalTok{p "all non{-}negative" if none \{ \_ \textless{} 0 \} @vals}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first}}{first}}\label{first}

\texttt{first\ \{\ COND\ \}\ @list} --- returns the first element for
which the block returns true, or \texttt{undef} if no element matches.
The alias \texttt{fst} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $f = first \{ \_ \textgreater{} 10 \} 3, 7, 12, 20}
\NormalTok{p $f   \# 12}
\NormalTok{1:1\_000\_000 |\textgreater{} first \{ \_ \% 9999 == 0 \} |\textgreater{} p  \# 9999}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min}}{min}}\label{min}

\texttt{min\ @list} --- returns the numerically smallest value from a
list. Compares all elements using numeric
(\texttt{\textless{}=\textgreater{}}) comparison, so stringy values are
coerced to numbers. Returns \texttt{undef} for an empty list. In stryke,
\texttt{min} is a global built-in (no import needed) and works directly
in \texttt{\textbar{}\textgreater{}} pipelines.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p min(5, 3, 9, 1)   \# 1}
\NormalTok{my @temps = (72.1, 68.5, 74.3)}
\NormalTok{@temps |\textgreater{} min |\textgreater{} p  \# 68.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max}}{max}}\label{max}

\texttt{max\ @list} --- returns the numerically largest value from a
list. Compares all elements using numeric
(\texttt{\textless{}=\textgreater{}}) comparison. Returns \texttt{undef}
for an empty list. Like \texttt{min}, this is a stryke built-in
available without imports and works in \texttt{\textbar{}\textgreater{}}
pipelines. Combine with \texttt{map} to extract max values from complex
structures.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p max(5, 3, 9, 1)   \# 9}
\NormalTok{1:100 |\textgreater{} map \{ \_ ** 2 \} |\textgreater{} max |\textgreater{} p  \# 10000}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum}}{sum}}\label{sum}

\texttt{sum\ @list} returns the numeric sum of all elements. Returns
\texttt{undef} for an empty list. \texttt{sum0} is identical except it
returns \texttt{0} for an empty list, which avoids the need for a
fallback \texttt{//\ 0} guard. Both are stryke built-ins that work in
\texttt{\textbar{}\textgreater{}} pipelines. Use \texttt{sum0} in
contexts where an empty input is expected and you need a safe numeric
default.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sum(1:100)    \# 5050}
\NormalTok{p sum0()          \# 0}
\NormalTok{@prices |\textgreater{} map \{ \_{-}\textgreater{}\{amount\} \} |\textgreater{} sum0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{product}}{product}}\label{product}

\texttt{product\ @list} --- returns the product of all numeric elements
in the list. Returns \texttt{undef} for an empty list. Useful for
computing factorials, combinatoric products, and compound multipliers.
In stryke this is a built-in that composes naturally with
\texttt{\textbar{}\textgreater{}} pipelines and \texttt{range}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p product(1:5)   \# 120}
\NormalTok{range(1, 10) |\textgreater{} product |\textgreater{} p  \# 3628800}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean}}{mean}}\label{mean}

\texttt{mean\ @list} --- returns the arithmetic mean (average) of a
numeric list. Computed as \texttt{sum\ /\ count} in a single pass.
Returns \texttt{undef} for an empty list. The result is always a
floating-point value even if all inputs are integers. Combine with
\texttt{map} to compute averages over extracted fields.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mean(2, 4, 6, 8)   \# 5}
\NormalTok{@students |\textgreater{} map \{ \_{-}\textgreater{}\{score\} \} |\textgreater{} mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{median}}{median}}\label{median}

\texttt{median\ @list} --- 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 \texttt{undef}
for an empty list.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p median(1, 3, 5, 7, 9)   \# 5}
\NormalTok{p median(1, 3, 5, 7)      \# 4}
\NormalTok{1:100 |\textgreater{} median |\textgreater{} p     \# 50.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode}}{mode}}\label{mode}

\texttt{mode\ @list} --- returns the most frequently occurring value in
the list. If there is a tie, the value that appears first in the list
wins. Returns \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mode(1, 2, 2, 3, 3, 3)   \# 3}
\NormalTok{my @logs = qw(INFO WARN INFO ERROR INFO)}
\NormalTok{p mode(@logs)  \# INFO}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stddev}}{stddev}}\label{stddev}

\texttt{stddev\ @list} (alias \texttt{std}) --- 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 \texttt{undef} for
an empty list.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p stddev(2, 4, 4, 4, 5, 5, 7, 9)   \# 2}
\NormalTok{1:10 |\textgreater{} std |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{variance}}{variance}}\label{variance}

\texttt{variance\ @list} --- returns the population variance of a
numeric list, computed as the mean of the squared deviations from the
mean. Like \texttt{stddev}, this uses N (not N-1) as the divisor. The
variance is \texttt{stddev\ **\ 2}. Returns \texttt{undef} for an empty
list. Useful for statistical analysis and as a building block for
higher-order stats.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p variance(2, 4, 4, 4, 5, 5, 7, 9)   \# 4}
\NormalTok{my @samples = map \{ rand(100) \} 1:1000}
\NormalTok{p variance(@samples)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sample}}{sample}}\label{sample}

\texttt{sample\ N,\ @list} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @pick = sample 3, 1:100}
\NormalTok{@pick |\textgreater{} e p   \# 3 random values}
\NormalTok{my @test\_cases = sample 10, @all\_cases}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shuffle}}{shuffle}}\label{shuffle}

\texttt{shuffle\ @list} --- 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 \texttt{shuf} is also
available. Commonly used with \texttt{\textbar{}\textgreater{}} and
\texttt{take} to draw random subsets.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @deck = shuffle 1:52}
\NormalTok{@deck |\textgreater{} take 5 |\textgreater{} e p   \# 5 random cards}
\NormalTok{my @randomized = shuffle @questions}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uniq}}{uniq}}\label{uniq}

\texttt{uniq\ @list} --- removes duplicate elements from a list,
preserving the order of first occurrence. Comparison is done by string
equality. The alias \texttt{uq} is also available. This is eager (not
streaming) and returns a new list. For streaming deduplication in
\texttt{\textbar{}\textgreater{}} pipelines, use \texttt{distinct}. For
type-specific comparison, see \texttt{uniqnum}, \texttt{uniqstr}, and
\texttt{uniqint}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @u = uniq 1, 2, 2, 3, 1, 3}
\NormalTok{@u |\textgreater{} e p   \# 1 2 3}
\NormalTok{my @hosts = uniq @all\_hosts}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uniqint}}{uniqint}}\label{uniqint}

\texttt{uniqint\ @list} --- removes duplicate elements comparing values
as integers. Each element is truncated to its integer part before
comparison, so \texttt{1.1} and \texttt{1.9} are considered equal (both
become \texttt{1}). The first occurrence is kept. This is useful when
you have floating-point data but care only about the integer portion for
uniqueness.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @u = uniqint 1, 1.1, 1.9, 2}
\NormalTok{@u |\textgreater{} e p   \# 1 2}
\NormalTok{my @distinct\_ids = uniqint @raw\_ids}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uniqnum}}{uniqnum}}\label{uniqnum}

\texttt{uniqnum\ @list} --- removes duplicate elements comparing values
as floating-point numbers. Unlike \texttt{uniq} (which compares as
strings), \texttt{uniqnum} treats \texttt{1.0} and \texttt{1.00} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @u = uniqnum 1.0, 1.00, 2.5, 2.50}
\NormalTok{@u |\textgreater{} e p   \# 1 2.5}
\NormalTok{my @prices = uniqnum @all\_prices}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uniqstr}}{uniqstr}}\label{uniqstr}

\texttt{uniqstr\ @list} --- removes duplicate elements comparing values
strictly as strings. This is the same comparison as \texttt{uniq} but
makes the intent explicit. Numeric values \texttt{1} and \texttt{1.0}
are considered different because their string representations differ.
Use \texttt{uniqstr} when you want to be explicit that string semantics
are intended.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @u = uniqstr "a", "b", "a", "c"}
\NormalTok{@u |\textgreater{} e p   \# a b c}
\NormalTok{my @tags = uniqstr @all\_tags}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip}}{zip}}\label{zip}

\texttt{zip(\textbackslash{}@a,\ \textbackslash{}@b,\ ...)} --- 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 \texttt{zp} is
also available. By default, \texttt{zip} pads shorter arrays with
\texttt{undef} (equivalent to \texttt{zip\_longest}). For truncating
behavior, use \texttt{zip\_shortest}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:3}
\NormalTok{my @b = ("a","b","c")}
\NormalTok{zip(\textbackslash{}@a, \textbackslash{}@b) |\textgreater{} e p   \# [1,a] [2,b] [3,c]}
\NormalTok{my @matrix = zip(\textbackslash{}@xs, \textbackslash{}@ys, \textbackslash{}@zs)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_longest}}{zip\_longest}}\label{zip_longest}

\texttt{zip\_longest(\textbackslash{}@a,\ \textbackslash{}@b,\ ...)} ---
combines arrays element-wise, padding shorter arrays with \texttt{undef}
to match the longest. This is the explicit version of the default
\texttt{zip} behavior. Every input array contributes exactly one element
per output tuple; missing elements become \texttt{undef}. Useful when
you need to process all data from unequal-length sources.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:3}
\NormalTok{my @b = ("x")}
\NormalTok{zip\_longest(\textbackslash{}@a, \textbackslash{}@b) |\textgreater{} e p   \# [1,x] [2,undef] [3,undef]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_shortest}}{zip\_shortest}}\label{zip_shortest}

\texttt{zip\_shortest(\textbackslash{}@a,\ \textbackslash{}@b,\ ...)}
--- combines arrays element-wise, stopping at the shortest input array.
No \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:5}
\NormalTok{my @b = ("x","y")}
\NormalTok{zip\_shortest(\textbackslash{}@a, \textbackslash{}@b) |\textgreater{} e p   \# [1,x] [2,y]}
\NormalTok{my @paired = zip\_shortest(\textbackslash{}@keys, \textbackslash{}@values)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chunked}}{chunked}}\label{chunked}

\texttt{chunked\ N,\ @list} --- 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 \texttt{chk} is also available. In stryke,
\texttt{chunked} is eager and returns a list of arrayrefs; for streaming
chunk behavior in pipelines, use \texttt{chunk}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @ch = chunked 3, 1:7}
\NormalTok{@ch |\textgreater{} e p   \# [1,2,3] [4,5,6] [7]}
\NormalTok{1:12 |\textgreater{} chunked 4 |\textgreater{} e \{ p join ",", @\_ \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{windowed}}{windowed}}\label{windowed}

\texttt{windowed\ N,\ @list} --- returns a sliding window of N
consecutive elements over the list. Each window is an arrayref. The
output contains \texttt{len\ -\ N\ +\ 1} windows. Unlike
\texttt{chunked}, windows overlap: each successive window advances by
one element. The alias \texttt{win} is also available. Useful for
computing moving averages, detecting patterns in sequences, or n-gram
extraction.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @w = windowed 3, 1:5}
\NormalTok{@w |\textgreater{} e p   \# [1,2,3] [2,3,4] [3,4,5]}
\NormalTok{my @deltas = windowed(2, @vals) |\textgreater{} map \{ \_{-}\textgreater{}[1] {-} \_{-}\textgreater{}[0] \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairs}}{pairs}}\label{pairs}

\texttt{pairs\ @list} --- takes a flat list and groups consecutive
elements into pairs, returning a list of two-element arrayrefs
\texttt{({[}\$k,\ \$v{]},\ ...)}. The input list must have an even
number of elements. Each pair can be accessed via array indexing
(\texttt{\_-\textgreater{}{[}0{]}}, \texttt{\_-\textgreater{}{[}1{]}}).
This is the inverse of \texttt{unpairs} and is commonly used to iterate
over hash-like flat lists in a structured way.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @p = pairs "a", 1, "b", 2}
\NormalTok{@p |\textgreater{} e \{ p "\_{-}\textgreater{}[0]=\_{-}\textgreater{}[1]" \}   \# a=1 b=2}
\NormalTok{my @entries = pairs \%hash}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unpairs}}{unpairs}}\label{unpairs}

\texttt{unpairs\ @list\_of\_pairs} --- flattens a list of two-element
arrayrefs back into a flat key-value list. This is the inverse of
\texttt{pairs}. Each arrayref \texttt{{[}\$k,\ \$v{]}} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @flat = unpairs ["a",1], ["b",2]}
\NormalTok{@flat |\textgreater{} e p   \# a 1 b 2}
\NormalTok{my \%h = unpairs @filtered\_pairs}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairkeys}}{pairkeys}}\label{pairkeys}

\texttt{pairkeys\ @list} --- extracts the keys (even-indexed elements)
from a flat pairlist. Given a list like
\texttt{("a",\ 1,\ "b",\ 2,\ "c",\ 3)}, returns
\texttt{("a",\ "b",\ "c")}. This is equivalent to
\texttt{map\ \{\ \_-\textgreater{}{[}0{]}\ \}\ pairs\ @list} but more
concise and efficient. Useful for extracting just the key side of a
key-value flat list without constructing intermediate pair objects.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @k = pairkeys "a", 1, "b", 2, "c", 3}
\NormalTok{@k |\textgreater{} e p   \# a b c}
\NormalTok{my @config\_pairs = (host =\textgreater{} "localhost", port =\textgreater{} 8080)}
\NormalTok{my @names = pairkeys @config\_pairs}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairvalues}}{pairvalues}}\label{pairvalues}

\texttt{pairvalues\ @list} --- extracts the values (odd-indexed
elements) from a flat pairlist. Given \texttt{("a",\ 1,\ "b",\ 2)},
returns \texttt{(1,\ 2)}. This is equivalent to
\texttt{map\ \{\ \_-\textgreater{}{[}1{]}\ \}\ pairs\ @list} but more
concise. Pair it with \texttt{pairkeys} to split a flat key-value list
into separate key and value arrays.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @v = pairvalues "a", 1, "b", 2}
\NormalTok{@v |\textgreater{} e p   \# 1 2}
\NormalTok{my @defaults = (timeout =\textgreater{} 30, retries =\textgreater{} 3)}
\NormalTok{my @settings = pairvalues @defaults}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairmap}}{pairmap}}\label{pairmap}

\texttt{pairmap\ BLOCK\ @list} --- maps over consecutive pairs in a flat
list, passing the key as \texttt{\$\_0} (or \texttt{\$a}) and the value
as \texttt{\$\_1} (or \texttt{\$b}). The block can return any number of
elements. This is the pair-aware equivalent of \texttt{map} and is ideal
for transforming hash-like flat lists. The result is a flat list of
whatever the block returns.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @out = pairmap \{ "$\_0=$\_1" \} "a", 1, "b", 2}
\NormalTok{@out |\textgreater{} e p   \# a=1 b=2}
\NormalTok{my @cfg\_pairs = (host =\textgreater{} "x", port =\textgreater{} 80)}
\NormalTok{my @upper = pairmap \{ uc($\_0), $\_1 \} @cfg\_pairs}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairgrep}}{pairgrep}}\label{pairgrep}

\texttt{pairgrep\ \{\ BLOCK\ \}\ @list} --- filters consecutive pairs
from a flat list, keeping only those where the block returns true. The
key is available as \texttt{\$\_0} (or \texttt{\$a}) and the value as
\texttt{\$\_1} (or \texttt{\$b}). Returns a flat list of the matching
key-value pairs. This is the pair-aware equivalent of \texttt{grep} and
is useful for filtering hash-like data by both key and value
simultaneously.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @big = pairgrep \{ $\_1 \textgreater{} 5 \} "a", 3, "b", 9, "c", 1}
\NormalTok{@big |\textgreater{} e p   \# b 9}
\NormalTok{my @alert\_pairs = (info =\textgreater{} 1, critical\_a =\textgreater{} 9, critical\_b =\textgreater{} 7)}
\NormalTok{my @important = pairgrep \{ $\_0 =\textasciitilde{} /\^{}critical/ \} @alert\_pairs}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairfirst}}{pairfirst}}\label{pairfirst}

\texttt{pairfirst\ \{\ BLOCK\ \}\ @list} --- returns the first pair from
a flat list where the block returns true, as a two-element list
\texttt{(\$key,\ \$value)}. The key is \texttt{\$\_0} (or \texttt{\$a})
and the value is \texttt{\$\_1} (or \texttt{\$b}). Short-circuits on the
first match. Returns an empty list if no pair matches. This is the
pair-aware equivalent of \texttt{first}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @hit = pairfirst \{ $\_1 \textgreater{} 5 \} "x", 2, "y", 8}
\NormalTok{p "@hit"   \# y 8}
\NormalTok{my @flags = (info =\textgreater{} 1, debug =\textgreater{} 7, trace =\textgreater{} 0)}
\NormalTok{my ($k, $v) = pairfirst \{ $\_0 eq "debug" \} @flags}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mesh}}{mesh}}\label{mesh}

\texttt{mesh(\textbackslash{}@a,\ \textbackslash{}@b,\ ...)} ---
interleaves multiple arrays into a flat list rather than arrayrefs.
While \texttt{zip} returns \texttt{({[}1,"a"{]},\ {[}2,"b"{]})},
\texttt{mesh} returns \texttt{(1,\ "a",\ 2,\ "b")}. This makes it ideal
for constructing hashes from parallel key and value arrays. The result
is a flat list suitable for direct hash assignment.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @k = ("a","b")}
\NormalTok{my @v = (1,2)}
\NormalTok{my \%h = mesh(\textbackslash{}@k, \textbackslash{}@v)}
\NormalTok{p $h\{a\}   \# 1}
\NormalTok{my \%lookup = mesh(\textbackslash{}@ids, \textbackslash{}@names)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mesh\_longest}}{mesh\_longest}}\label{mesh_longest}

\texttt{mesh\_longest(\textbackslash{}@a,\ \textbackslash{}@b,\ ...)}
--- interleaves arrays into a flat list, padding shorter arrays with
\texttt{undef} to match the longest. Like \texttt{mesh}, the output is
flat (not arrayrefs). Missing elements become \texttt{undef} in the
output sequence. Use this when building a flat interleaved list from
arrays of unequal length where you need every element represented.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:3}
\NormalTok{my @b = ("x")}
\NormalTok{my @r = mesh\_longest(\textbackslash{}@a, \textbackslash{}@b)}
\NormalTok{@r |\textgreater{} e p   \# 1 x 2 undef 3 undef}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mesh\_shortest}}{mesh\_shortest}}\label{mesh_shortest}

\texttt{mesh\_shortest(\textbackslash{}@a,\ \textbackslash{}@b,\ ...)}
--- interleaves arrays into a flat list, stopping at the shortest input
array. No \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:3}
\NormalTok{my @b = ("x","y")}
\NormalTok{my @r = mesh\_shortest(\textbackslash{}@a, \textbackslash{}@b)}
\NormalTok{@r |\textgreater{} e p   \# 1 x 2 y}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition}}{partition}}\label{partition}

\texttt{partition} --- functional / iterator builtin. Alias for
\texttt{take\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frequencies}}{frequencies}}\label{frequencies}

\texttt{frequencies} (aliases \texttt{freq}, \texttt{frq}) 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 \texttt{dd} for inspection or \texttt{to\_json} for
serialization.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @words = qw(apple banana apple cherry banana apple)}
\NormalTok{my $counts = freq @words}
\NormalTok{p $counts   \# \{apple =\textgreater{} 3, banana =\textgreater{} 2, cherry =\textgreater{} 1\}}
\NormalTok{rl("access.log") |\textgreater{} map \{ /\^{}(\textbackslash{}S+)/ \&\& $1 \} |\textgreater{} freq |\textgreater{} dd}
\NormalTok{my @rolls = map \{ 1 + int(rand 6) \} 1:1000}
\NormalTok{frq(@rolls) |\textgreater{} to\_json |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tally}}{tally}}\label{tally}

\texttt{tally} 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\textquotesingle s \texttt{Enumerable\#tally} or
Python\textquotesingle s \texttt{Counter}. Similar to
\texttt{frequencies} but follows the Ruby naming convention.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $t = tally("a", "b", "a", "c", "a", "b")}
\NormalTok{p $t{-}\textgreater{}\{a\}   \# 3}
\NormalTok{p $t{-}\textgreater{}\{b\}   \# 2}
\NormalTok{qw(red blue red green blue red) |\textgreater{} tally |\textgreater{} dd}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{interleave}}{interleave}}\label{interleave}

\texttt{interleave} (alias \texttt{il}) 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 \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @keys = qw(name age city)}
\NormalTok{my @vals = ("Alice", 30, "NYC")}
\NormalTok{my @pairs = il \textbackslash{}@keys, \textbackslash{}@vals}
\NormalTok{p @pairs   \# name, Alice, age, 30, city, NYC}
\NormalTok{my \%h = il \textbackslash{}@keys, \textbackslash{}@vals}
\NormalTok{p $h\{name\} \# Alice}
\NormalTok{my @rgb = il [255,0,0], [0,255,0], [0,0,255]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pluck}}{pluck}}\label{pluck}

\texttt{pluck\ KEY,\ LIST\_OF\_HASHREFS} --- extract a single key from
each hashref in the list.

For each element, \texttt{pluck} dereferences it as a hashref and
returns the value at the given key. Elements where the key is missing
yield \texttt{undef}. 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
\texttt{map\ \{\ \_-\textgreater{}\{KEY\}\ \}} but more readable and
optimized internally.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{@users |\textgreater{} pluck "name" |\textgreater{} e p}
\NormalTok{my @ids = pluck "id", @records}
\NormalTok{@rows |\textgreater{} pluck "email" |\textgreater{} distinct |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grep\_v}}{grep\_v}}\label{grep_v}

\texttt{grep\_v\ PATTERN,\ LIST} --- inverse grep: reject elements that
match the pattern, keep the rest.

This is the complement of \texttt{grep} --- 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
\texttt{grep\ \{\ !/pattern/\ \}} double-negation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{@words |\textgreater{} grep\_v /\^{} \#/ |\textgreater{} e p          \# drop comments}
\NormalTok{my @clean = grep\_v qr/tmp/, @files}
\NormalTok{stdin |\textgreater{} grep\_v /\^{}\textbackslash{}s*$/ |\textgreater{} e p        \# drop blank lines}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{select\_keys}}{select\_keys}}\label{select_keys}

\texttt{select\_keys} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = select\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map select\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clamp}}{clamp}}\label{clamp}

\texttt{clamp} (alias \texttt{clp}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @scores = (105, {-}3, 42, 99, 200)}
\NormalTok{my @clamped = clp 0, 100, @scores}
\NormalTok{p @clamped   \# 100, 0, 42, 99, 100}
\NormalTok{my $val = clp 0, 255, $input   \# bound to byte range}
\NormalTok{my @pct = map \{ clp 0.0, 1.0, \_ \} @raw\_ratios}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize}}{normalize}}\label{normalize}

\texttt{normalize} (alias \texttt{nrm}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @temps = (32, 68, 100, 212)}
\NormalTok{my @normed = nrm @temps}
\NormalTok{p @normed   \# 0, 0.2, 0.377..., 1}
\NormalTok{my @pixels = nrm @raw\_intensities}
\NormalTok{@pixels |\textgreater{} map \{ int(\_ * 255) \} |\textgreater{} e p  \# scale to 0{-}255}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compose}}{compose}}\label{compose}

\texttt{compose} (alias \texttt{comp}) creates a right-to-left function
composition. Given
\texttt{compose(\textbackslash{}\&f,\ \textbackslash{}\&g)}, calling the
result with \texttt{x} computes \texttt{f(g(x))}. 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $double = fn \{ $\_[0] * 2 \}}
\NormalTok{my $inc    = fn \{ $\_[0] + 1 \}}
\NormalTok{my $f = compose($inc, $double)}
\NormalTok{p $f{-}\textgreater{}(5)   \# 11  (double 5 → 10, inc 10 → 11)}

\NormalTok{my $pipeline = compose(}
\NormalTok{    fn \{ join ",", @\{$\_[0]\} \},}
\NormalTok{    fn \{ [sort @\{$\_[0]\}] \},}
\NormalTok{    fn \{ [grep \{ \_ \textgreater{} 2 \} @\{$\_[0]\}] \},}
\NormalTok{)}
\NormalTok{p $pipeline{-}\textgreater{}([3,1,4,1,5])  \# 3,4,5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partial}}{partial}}\label{partial}

\texttt{partial} returns a partially applied function --- the bound
arguments are prepended to any arguments supplied at call time.
\texttt{partial(\textbackslash{}\&f,\ @bound)-\textgreater{}(x)} is
equivalent to \texttt{f(@bound,\ x)}. This is the standard partial
application from functional programming, useful for creating specialized
versions of general functions without closures.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $add = fn \{ $\_[0] + $\_[1] \}}
\NormalTok{my $add5 = partial($add, 5)}
\NormalTok{p $add5{-}\textgreater{}(3)   \# 8}

\NormalTok{my $log = fn \{ p "[$\_[0]] $\_[1]" \}}
\NormalTok{my $warn\_log = partial($log, "WARN")}
\NormalTok{$warn\_log{-}\textgreater{}("disk full")   \# [WARN] disk full}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{curry}}{curry}}\label{curry}

\texttt{curry} 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.
\texttt{curry(\textbackslash{}\&f,\ N)-\textgreater{}(a)-\textgreater{}(b)}
calls \texttt{f(a,\ b)} when N=2. If all arguments are supplied at once,
it calls immediately.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $add = curry(fn \{ $\_[0] + $\_[1] \}, 2)}
\NormalTok{my $add5 = $add{-}\textgreater{}(5)}
\NormalTok{p $add5{-}\textgreater{}(3)       \# 8}
\NormalTok{p $add{-}\textgreater{}(10, 20)   \# 30  (enough args — calls immediately)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{memoize}}{memoize}}\label{memoize}

\texttt{memoize} (alias \texttt{memo}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $fib = memoize(fn \{}
\NormalTok{    my $n = $\_[0]}
\NormalTok{    $n \textless{} 2 ? $n : $fib{-}\textgreater{}($n{-}1) + $fib{-}\textgreater{}($n{-}2)}
\NormalTok{\})}
\NormalTok{p $fib{-}\textgreater{}(30)   \# instant (without memoize: \textasciitilde{}1B calls)}

\NormalTok{my $fetch\_user = memo(fn \{ fetch\_json("https://api/users/$\_[0]") \})}
\NormalTok{$fetch\_user{-}\textgreater{}(42)   \# hits API}
\NormalTok{$fetch\_user{-}\textgreater{}(42)   \# returns cached}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{once}}{once}}\label{once}

\texttt{once} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $init = once(fn \{ p "initializing..."}
\NormalTok{    42 \})}
\NormalTok{p $init{-}\textgreater{}()   \# prints "initializing..." → 42}
\NormalTok{p $init{-}\textgreater{}()   \# 42 (no print — cached)}
\NormalTok{p $init{-}\textgreater{}()   \# 42 (still cached)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{constantly}}{constantly}}\label{constantly}

\texttt{constantly} (alias \texttt{const}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $zero = constantly(0)}
\NormalTok{p $zero{-}\textgreater{}("anything")   \# 0}
\NormalTok{my @defaults = map \{ constantly(0){-}\textgreater{}() \} 1:5   \# [0,0,0,0,0]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{complement}}{complement}}\label{complement}

\texttt{complement} (alias \texttt{compl}) wraps a predicate function
and returns a new function that negates its boolean result.
\texttt{complement(\textbackslash{}\&even?)-\textgreater{}(3)} returns
true. This is the functional equivalent of \texttt{!f(x)} without
creating a closure.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $even = fn \{ $\_[0] \% 2 == 0 \}}
\NormalTok{my $odd = complement($even)}
\NormalTok{p $odd{-}\textgreater{}(3)   \# 1}
\NormalTok{p $odd{-}\textgreater{}(4)   \# 0}
\NormalTok{1:10 |\textgreater{} grep \{ complement($even){-}\textgreater{}(\_) \} |\textgreater{} e p  \# 1 3 5 7 9}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{juxt}}{juxt}}\label{juxt}

\texttt{juxt} (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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $stats = juxt(fn \{ min @\_ \}, fn \{ max @\_ \}, fn \{ avg @\_ \})}
\NormalTok{my @r = $stats{-}\textgreater{}(3, 1, 4, 1, 5)}
\NormalTok{p "@r"   \# 1 5 2.8}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnil}}{fnil}}\label{fnil}

\texttt{fnil} wraps a function so that any \texttt{undef} arguments are
replaced with the given defaults before the function is called. This
eliminates repetitive \texttt{//\ \$default} patterns inside function
bodies.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $greet = fnil(fn \{ "Hello, $\_[0]!" \}, "World")}
\NormalTok{p $greet{-}\textgreater{}(undef)    \# Hello, World!}
\NormalTok{p $greet{-}\textgreater{}("Alice")  \# Hello, Alice!}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deep\_clone}}{deep\_clone}}\label{deep_clone}

\texttt{deep\_clone} (alias \texttt{dclone}) 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\textquotesingle s
\texttt{structuredClone} or Perl\textquotesingle s
\texttt{Storable::dclone}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $orig = \{users =\textgreater{} [\{name =\textgreater{} "Alice"\}], meta =\textgreater{} \{v =\textgreater{} 1\}\}}
\NormalTok{my $copy = deep\_clone($orig)}
\NormalTok{$copy{-}\textgreater{}\{users\}[0]\{name\} = "Bob"}
\NormalTok{p $orig{-}\textgreater{}\{users\}[0]\{name\}   \# Alice (unchanged)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deep\_merge}}{deep\_merge}}\label{deep_merge}

\texttt{deep\_merge} (alias \texttt{dmerge}) 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\textquotesingle s
\texttt{deep\_merge}, and config-file overlay patterns. Returns a new
hash ref --- neither input is modified.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $defaults = \{db =\textgreater{} \{host =\textgreater{} "localhost", port =\textgreater{} 5432\}, debug =\textgreater{} 0\}}
\NormalTok{my $overrides = \{db =\textgreater{} \{port =\textgreater{} 3306\}, debug =\textgreater{} 1\}}
\NormalTok{my $cfg = deep\_merge($defaults, $overrides)}
\NormalTok{p $cfg{-}\textgreater{}\{db\}\{host\}   \# localhost (from defaults)}
\NormalTok{p $cfg{-}\textgreater{}\{db\}\{port\}   \# 3306 (overridden)}
\NormalTok{p $cfg{-}\textgreater{}\{debug\}      \# 1 (overridden)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deep\_equal}}{deep\_equal}}\label{deep_equal}

\texttt{deep\_equal} (alias \texttt{deq}) 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\textquotesingle s
\texttt{assert.deepStrictEqual}, Lodash \texttt{isEqual}, or
Python\textquotesingle s \texttt{==} on nested dicts/lists.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p deep\_equal([1, \{a =\textgreater{} 2\}], [1, \{a =\textgreater{} 2\}])   \# 1}
\NormalTok{p deep\_equal([1, \{a =\textgreater{} 2\}], [1, \{a =\textgreater{} 3\}])   \# 0}
\NormalTok{p deq(\{x =\textgreater{} [1,2]\}, \{x =\textgreater{} [1,2]\})            \# 1}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-stryke-extensions}
\chapter{stryke Extensions}\label{stryke-extensions}

19 topics

\section{\texorpdfstring{\texttt{fn}}{fn}}\label{fn}

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 \texttt{return} is used.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn dbl($x) \{ $x * 2 \}}
\NormalTok{my $f = fn \{ \_ * 2 \}}
\NormalTok{my $add = fn ($a: Int, $b: Int) \{ $a + $b \}}

\NormalTok{\# Default parameter values:}
\NormalTok{fn greet($name = "world") \{ p "hello $name" \}}
\NormalTok{greet()           \# hello world}
\NormalTok{greet("Alice")    \# hello Alice}

\NormalTok{fn range\_check($x, $min = 0, $max = 100) \{ $min \textless{}= $x \textless{}= $max \}}
\NormalTok{fn with\_list(@items = (1, 2, 3)) \{ join "{-}", @items \}}
\NormalTok{fn with\_hash(\%opts = (debug =\textgreater{} 0)) \{ $opts\{debug\} \}}
\end{Highlighting}
\end{Shaded}

Default values are evaluated at call time if the argument is not
provided.

\section{\texorpdfstring{\texttt{struct}}{struct}}\label{struct}

\texttt{struct} 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.

\textbf{Declaration:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{struct Point \{ x =\textgreater{} Float, y =\textgreater{} Float \}           \# typed fields}
\NormalTok{struct Point \{ x =\textgreater{} Float = 0.0, y =\textgreater{} Float = 0.0 \} \# with defaults}
\NormalTok{struct Pair \{ key, value \}                        \# untyped (Any)}
\end{Highlighting}
\end{Shaded}

\textbf{Construction:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $p = Point(x =\textgreater{} 1.5, y =\textgreater{} 2.0)  \# function{-}call with named args}
\NormalTok{my $p = Point(1.5, 2.0)            \# positional (declaration order)}
\NormalTok{my $p = Point{-}\textgreater{}new(x =\textgreater{} 1.5, y =\textgreater{} 2.0) \# traditional OO style}
\NormalTok{my $p = Point()                    \# uses defaults if defined}
\end{Highlighting}
\end{Shaded}

\textbf{Field access (getter/setter):}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $p{-}\textgreater{}x       \# getter (0 args)}
\NormalTok{$p{-}\textgreater{}x(3.0)    \# setter (1 arg)}
\end{Highlighting}
\end{Shaded}

\textbf{User-defined methods:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{struct Circle \{}
\NormalTok{    radius =\textgreater{} Float,}
\NormalTok{    fn area \{ 3.14159 * $self{-}\textgreater{}radius ** 2 \}}
\NormalTok{    fn scale($factor: Float) \{}
\NormalTok{        Circle(radius =\textgreater{} $self{-}\textgreater{}radius * $factor)}
\NormalTok{    \}}
\NormalTok{\}}
\NormalTok{my $c = Circle(radius =\textgreater{} 5)}
\NormalTok{p $c{-}\textgreater{}area        \# 78.53975}
\NormalTok{p $c{-}\textgreater{}scale(2)    \# Circle(radius =\textgreater{} 10)}
\end{Highlighting}
\end{Shaded}

\textbf{Built-in methods:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $q = $p{-}\textgreater{}with(x =\textgreater{} 5)  \# functional update — new instance}
\NormalTok{my $h = $p{-}\textgreater{}to\_hash       \# \{ x =\textgreater{} 1.5, y =\textgreater{} 2.0 \}}
\NormalTok{my @f = $p{-}\textgreater{}fields        \# (x, y)}
\NormalTok{my $c = $p{-}\textgreater{}clone         \# deep copy}
\end{Highlighting}
\end{Shaded}

\textbf{Smart stringify:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $p  \# Point(x =\textgreater{} 1.5, y =\textgreater{} 2)}
\end{Highlighting}
\end{Shaded}

\textbf{Structural equality:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $a = Point(1, 2)}
\NormalTok{my $b = Point(1, 2)}
\NormalTok{p $a == $b  \# 1 (compares all fields)}
\end{Highlighting}
\end{Shaded}

Note: field type is checked at construction and mutation; unknown field
names are fatal errors.

\section{\texorpdfstring{\texttt{typed}}{typed}}\label{typed}

\texttt{typed} adds optional runtime type annotations to lexical
variables and subroutine parameters. When a \texttt{typed} declaration
is in effect, stryke inserts a lightweight check at assignment time that
verifies the value matches the declared type (\texttt{Int},
\texttt{Str}, \texttt{Float}, \texttt{Bool}, \texttt{ArrayRef},
\texttt{HashRef}, or a user-defined \texttt{struct} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{typed my $x : Int = 42}
\NormalTok{typed my $name : Str = "hello"}
\NormalTok{typed my $pi : Float = 3.14}
\NormalTok{my $add = fn ($a: Int, $b: Int) \{ $a + $b \}}
\NormalTok{p $add{-}\textgreater{}(3, 4)   \# 7}
\end{Highlighting}
\end{Shaded}

Note: assigning a value of the wrong type raises a runtime exception
immediately.

You can mix typed and untyped variables freely in the same scope, so
adopting \texttt{typed} is incremental --- annotate the variables that
matter and leave the rest dynamic. Subroutine parameters declared with
type annotations in \texttt{fn} are checked on every call, giving you
contract-style validation at function boundaries without a separate
assertion library.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{typed my @nums : Int = (1, 2, 3)}
\NormalTok{typed my \%cfg : Str = (host =\textgreater{} "localhost", port =\textgreater{} "8080")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{match}}{match}}\label{match}

Algebraic pattern matching (stryke extension).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{match ($val) \{}
\NormalTok{    /\^{}\textbackslash{}d+$/ =\textgreater{} p "number: $val",}
\NormalTok{    [1, 2, \_] =\textgreater{} p "array starting with 1,2",}
\NormalTok{    \{ name =\textgreater{} $n \} =\textgreater{} p "name is $n",}
\NormalTok{    \_ =\textgreater{} p "default",}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Patterns: regex, array, hash, literal, wildcard \texttt{\_}. Optional
\texttt{if} guard per arm.

\section{\texorpdfstring{\texttt{frozen}}{frozen}}\label{frozen}

Declare an immutable lexical variable. \texttt{const\ my} and
\texttt{frozen\ my} are interchangeable spellings; \texttt{const} reads
more naturally for engineers coming from other languages.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{const my $pi = 3.14159}
\NormalTok{\# $pi = 3  \# ERROR: cannot assign to frozen variable}

\NormalTok{frozen my @primes = (2, 3, 5, 7, 11)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fore}}{fore}}\label{fore}

Side-effect-only list iterator (like \texttt{map} but void, returns item
count).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{qw(a b c) |\textgreater{} e p           \# prints a, b, c; returns 3}
\NormalTok{1:5 |\textgreater{} map \_ * 2 |\textgreater{} e p  \# prints 2,4,6,8,10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ep}}{ep}}\label{ep}

\texttt{ep} --- shorthand for \texttt{e\ \{\ p\ \}} (foreach + print).
Iterates the list and prints each element.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{qw(a b c) |\textgreater{} ep            \# prints a, b, c (one per line)}
\NormalTok{filef |\textgreater{} sorted |\textgreater{} ep      \# print sorted file list}
\NormalTok{1:5 |\textgreater{} map \_ * 2 |\textgreater{} ep   \# prints 2,4,6,8,10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{p}}{p}}\label{p-1}

\texttt{p} --- alias for \texttt{say} (print with newline).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p "hello"       \# hello\textbackslash{}n}
\NormalTok{p 42            \# 42\textbackslash{}n}
\NormalTok{1:5 |\textgreater{} e p     \# prints each on its own line}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gen}}{gen}}\label{gen}

Create a generator --- lazy \texttt{yield} values on demand.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $g = gen \{ yield \_ for 1:5 \}}
\NormalTok{my ($val, $more) = @\{$g{-}\textgreater{}next\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yield}}{yield}}\label{yield}

Yield a value from inside a \texttt{gen\ \{\ \}} generator block,
suspending the generator until the consumer calls
\texttt{-\textgreater{}next} again. Each \texttt{yield} produces one
element in the lazy sequence. When the block finishes without yielding,
the generator signals exhaustion. This is the stryke equivalent of
Python\textquotesingle s \texttt{yield} or Rust\textquotesingle s
\texttt{Iterator::next}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $fib = gen \{}
\NormalTok{    my ($a, $b) = (0, 1)}
\NormalTok{    while (1) \{}
\NormalTok{        yield $a}
\NormalTok{        ($a, $b) = ($b, $a + $b)}
\NormalTok{    \}}
\NormalTok{\}}
\NormalTok{for (1:10) \{}
\NormalTok{    my ($val) = @\{$fib{-}\textgreater{}next\}}
\NormalTok{    p $val}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trace}}{trace}}\label{trace}

Trace \texttt{mysync} mutations to stderr (tagged with worker index
under \texttt{fan}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{trace \{ fan 10 \{ $counter++ \} \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{timer}}{timer}}\label{timer}

Measure wall-clock milliseconds for a block.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ms = timer \{ heavy\_work() \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bench}}{bench}}\label{bench}

Benchmark a block N times; returns \texttt{"min/mean/p99"}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $report = bench \{ work() \} 1000}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eval\_timeout}}{eval\_timeout}}\label{eval_timeout}

Run a block with a wall-clock timeout (seconds).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{eval\_timeout 5 \{ slow\_operation() \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{retry}}{retry}}\label{retry}

Retry a block on failure.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{retry \{ http\_call() \} times =\textgreater{} 3, backoff =\textgreater{} \textquotesingle{}exponential\textquotesingle{}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rate\_limit}}{rate\_limit}}\label{rate_limit}

Limit invocations per time window.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{rate\_limit(10, "1s") \{ hit\_api() \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{every}}{every}}\label{every}

Run a block at a fixed interval.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{every "500ms" \{ tick() \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{watch}}{watch}}\label{watch}

Watch a single file for changes (non-parallel).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{watch "/tmp/x", fn \{ process \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capture}}{capture}}\label{capture}

Run a command and capture structured output. Returns an object with
\texttt{-\textgreater{}stdout}, \texttt{-\textgreater{}stderr},
\texttt{-\textgreater{}exitcode}, and \texttt{-\textgreater{}failed}
methods. When piped to \texttt{lines} or \texttt{words}, stdout is
auto-extracted so you can chain directly.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $r = capture("ls {-}la")}
\NormalTok{p $r{-}\textgreater{}stdout, $r{-}\textgreater{}stderr, $r{-}\textgreater{}exitcode}
\NormalTok{capture("ps aux") |\textgreater{} lines |\textgreater{} map \{ columns \} |\textgreater{} tbl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-data-serialization}
\chapter{Data \& Serialization}\label{data-serialization}

45 topics

\section{\texorpdfstring{\texttt{json\_encode}}{json\_encode}}\label{json_encode}

\texttt{json\_encode} 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 \texttt{json\_decode} to round-trip back.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%cfg = (debug =\textgreater{} 1, paths =\textgreater{} ["/tmp", "/var"])}
\NormalTok{my $j = json\_encode(\textbackslash{}\%cfg)}
\NormalTok{p $j   \# \{"debug":1,"paths":["/tmp","/var"]\}}
\NormalTok{$j |\textgreater{} spurt "/tmp/cfg.json"$1}

\NormalTok{Note: undef becomes JSON \textasciigrave{}null\textasciigrave{}; booleans serialize as \textasciigrave{}true\textasciigrave{}/\textasciigrave{}false\textasciigrave{}.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_decode}}{json\_decode}}\label{json_decode}

\texttt{json\_decode} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $data = json\_decode(\textquotesingle{}\{"name":"stryke","ver":1\}\textquotesingle{})}
\NormalTok{p $data{-}\textgreater{}\{name\}   \# stryke}
\NormalTok{slurp("data.json") |\textgreater{} json\_decode |\textgreater{} dd$1}

\NormalTok{Note: JSON \textasciigrave{}null\textasciigrave{} becomes Perl \textasciigrave{}undef\textasciigrave{}; trailing commas and comments are not allowed.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_jq}}{json\_jq}}\label{json_jq}

\texttt{json\_jq} applies a jq-style query expression to a stryke data
structure and returns the matched value. This brings the power of the
\texttt{jq} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $data = json\_decode(slurp "api.json")}
\NormalTok{p json\_jq($data, ".results[0].name")}
\NormalTok{my $cfg = rj "config.json"}
\NormalTok{p json\_jq($cfg, ".database.host")  \# deep extract}
\NormalTok{fetch\_json("https://api.example.com/users") |\textgreater{} json\_jq(".data[0].email") |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_json}}{to\_json}}\label{to_json}

\texttt{to\_json} (alias \texttt{tj}) converts a stryke data structure
into a JSON string, functioning as a convenient shorthand for
\texttt{json\_encode}. It accepts hashrefs, arrayrefs, scalars, and
nested combinations, producing compact JSON output suitable for APIs,
config files, or inter-process communication. The alias \texttt{tj} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%user = (name =\textgreater{} "Bob", age =\textgreater{} 30)}
\NormalTok{p tj \textbackslash{}\%user   \# \{"age":30,"name":"Bob"\}}
\NormalTok{my @items = map \{ \{id =\textgreater{} \_, val =\textgreater{} \_ * 2\} \} 1:3}
\NormalTok{p tj \textbackslash{}@items  \# [\{"id":1,"val":2\},\{"id":2,"val":4\},\{"id":3,"val":6\}]}
\NormalTok{@data |\textgreater{} tj |\textgreater{} spurt "out.json"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_csv}}{to\_csv}}\label{to_csv}

\texttt{to\_csv} (alias \texttt{tc}) 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 \texttt{tc} keeps one-liners terse when piping query
results or API responses straight to CSV.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @rows = (\{name =\textgreater{} "Alice", age =\textgreater{} 30\}, \{name =\textgreater{} "Bob", age =\textgreater{} 25\})}
\NormalTok{p tc \textbackslash{}@rows   \# name,age\textbackslash{}nAlice,30\textbackslash{}nBob,25}
\NormalTok{tc(\textbackslash{}@rows) |\textgreater{} spurt "people.csv"}
\NormalTok{my @grid = ([1, 2, 3], [4, 5, 6])}
\NormalTok{p tc \textbackslash{}@grid   \# 1,2,3\textbackslash{}n4,5,6}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_toml}}{to\_toml}}\label{to_toml}

\texttt{to\_toml} (alias \texttt{tt}) serializes a stryke hashref into a
TOML-formatted string. TOML is a popular configuration format that maps
cleanly to hash structures, making \texttt{tt} 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 \texttt{toml\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%cfg = (database =\textgreater{} \{host =\textgreater{} "localhost", port =\textgreater{} 5432\}, debug =\textgreater{} 1)}
\NormalTok{p tt \textbackslash{}\%cfg}
\NormalTok{\# [database]}
\NormalTok{\# host = "localhost"}
\NormalTok{\# port = 5432}
\NormalTok{\# debug = 1}
\NormalTok{tt(\textbackslash{}\%cfg) |\textgreater{} spurt "config.toml"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_yaml}}{to\_yaml}}\label{to_yaml}

\texttt{to\_yaml} (alias \texttt{ty}) 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 \texttt{yaml\_decode}. The alias \texttt{ty}
is convenient for quick inspection of complex data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%app = (name =\textgreater{} "myapp", deps =\textgreater{} ["tokio", "serde"], version =\textgreater{} "1.0")}
\NormalTok{p ty \textbackslash{}\%app}
\NormalTok{\# name: myapp}
\NormalTok{\# version: "1.0"}
\NormalTok{\# deps:}
\NormalTok{\#   {-} tokio}
\NormalTok{\#   {-} serde}
\NormalTok{ty(\textbackslash{}\%app) |\textgreater{} spurt "app.yaml"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_xml}}{to\_xml}}\label{to_xml}

\texttt{to\_xml} (alias \texttt{tx}) 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 \texttt{xml\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%doc = (root =\textgreater{} \{title =\textgreater{} "Hello", items =\textgreater{} ["a", "b", "c"]\})}
\NormalTok{p tx \textbackslash{}\%doc}
\NormalTok{\# \textless{}root\textgreater{}\textless{}title\textgreater{}Hello\textless{}/title\textgreater{}\textless{}items\textgreater{}a\textless{}/items\textgreater{}\textless{}items\textgreater{}b\textless{}/items\textgreater{}\textless{}items\textgreater{}c\textless{}/items\textgreater{}\textless{}/root\textgreater{}}
\NormalTok{tx(\textbackslash{}\%doc) |\textgreater{} spurt "doc.xml"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_html}}{to\_html}}\label{to_html}

\texttt{to\_html} (alias \texttt{th}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fr |\textgreater{} map +\{name =\textgreater{} \_, size =\textgreater{} format\_bytes(size)\} |\textgreater{} th |\textgreater{} to\_file("report.html")}
\NormalTok{my @rows = (\{name =\textgreater{} "Alice", age =\textgreater{} 30\}, \{name =\textgreater{} "Bob", age =\textgreater{} 25\})}
\NormalTok{@rows |\textgreater{} th |\textgreater{} to\_file("people.html")}
\NormalTok{th(\{host =\textgreater{} "localhost", port =\textgreater{} 5432\}) |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_markdown}}{to\_markdown}}\label{to_markdown}

\texttt{to\_markdown} (aliases \texttt{to\_md}, \texttt{tmd}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fr |\textgreater{} map +\{name =\textgreater{} \_, size =\textgreater{} format\_bytes(size)\} |\textgreater{} tmd |\textgreater{} to\_file("report.md")}
\NormalTok{my @rows = (\{name =\textgreater{} "Alice", age =\textgreater{} 30\}, \{name =\textgreater{} "Bob", age =\textgreater{} 25\})}
\NormalTok{@rows |\textgreater{} tmd |\textgreater{} p}
\NormalTok{\# | name | age |}
\NormalTok{\# | {-}{-}{-} | {-}{-}{-} |}
\NormalTok{\# | Alice | 30 |}
\NormalTok{\# | Bob | 25 |}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_json}}{from\_json}}\label{from_json}

\texttt{from\_json} (alias \texttt{fj}) parses a JSON string into a
stryke data structure (hashref, arrayref, scalar). This is the inverse
of \texttt{to\_json} and the idiomatic way to decode JSON responses from
APIs, config files, or inter-process communication. The Rust-backed
parser handles large documents efficiently.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $json = \textquotesingle{}\{"name":"Alice","age":30\}\textquotesingle{}}
\NormalTok{my $data = from\_json($json)}
\NormalTok{p $data{-}\textgreater{}\{name\}   \# Alice}
\NormalTok{my $arr = fj \textquotesingle{}[1, 2, \{"x": 3\}]\textquotesingle{}}
\NormalTok{p $arr{-}\textgreater{}[2]\{x\}    \# 3}
\NormalTok{slurp("config.json") |\textgreater{} fj}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_yaml}}{from\_yaml}}\label{from_yaml}

\texttt{from\_yaml} (alias \texttt{fy}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $yaml = "name: Alice\textbackslash{}nage: 30"}
\NormalTok{my $data = from\_yaml($yaml)}
\NormalTok{p $data{-}\textgreater{}\{name\}   \# Alice}
\NormalTok{slurp("config.yaml") |\textgreater{} fy |\textgreater{} say \_{-}\textgreater{}\{database\}\{host\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_toml}}{from\_toml}}\label{from_toml}

\texttt{from\_toml} (alias \texttt{ftoml}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $toml = "[package]\textbackslash{}nname = \textbackslash{}"myapp\textbackslash{}"\textbackslash{}nversion = \textbackslash{}"1.0\textbackslash{}""}
\NormalTok{my $data = from\_toml($toml)}
\NormalTok{p $data{-}\textgreater{}\{package\}\{name\}   \# myapp}
\NormalTok{slurp("Cargo.toml") |\textgreater{} ftoml |\textgreater{} say \_{-}\textgreater{}\{package\}\{version\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_xml}}{from\_xml}}\label{from_xml}

\texttt{from\_xml} (alias \texttt{fx}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $xml = \textquotesingle{}\textless{}root\textgreater{}\textless{}name\textgreater{}Alice\textless{}/name\textgreater{}\textless{}age\textgreater{}30\textless{}/age\textgreater{}\textless{}/root\textgreater{}\textquotesingle{}}
\NormalTok{my $data = from\_xml($xml)}
\NormalTok{p $data{-}\textgreater{}\{root\}\{name\}   \# Alice}
\NormalTok{slurp("config.xml") |\textgreater{} fx |\textgreater{} say \_{-}\textgreater{}\{config\}\{database\}\{host\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_csv}}{from\_csv}}\label{from_csv}

\texttt{from\_csv} (alias \texttt{fcsv}) parses a CSV string into an
arrayref of hashrefs, treating the first line as headers. This is the
inverse of \texttt{to\_csv} and handles quoted fields containing commas
according to RFC 4180.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $csv = "name,age\textbackslash{}nAlice,30\textbackslash{}nBob,25"}
\NormalTok{my $rows = from\_csv($csv)}
\NormalTok{p $rows{-}\textgreater{}[0]\{name\}   \# Alice}
\NormalTok{p $rows{-}\textgreater{}[1]\{age\}    \# 25}
\NormalTok{slurp("data.csv") |\textgreater{} fcsv |\textgreater{} grep \{ \_{-}\textgreater{}\{age\} \textgreater{} 25 \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xopen}}{xopen}}\label{xopen}

\texttt{xopen} (alias \texttt{xo}) opens a file or URL with the system
default handler --- \texttt{open} on macOS, \texttt{xdg-open} on Linux,
\texttt{start} 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 \texttt{xopen} and
the OS opens it in the appropriate app (browser for HTML, viewer for
PDF, editor for text).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fr |\textgreater{} map +\{name =\textgreater{} \_, size =\textgreater{} format\_bytes(size)\} |\textgreater{} th |\textgreater{} to\_file("report.html") |\textgreater{} xopen}
\NormalTok{xopen "https://example.com"}
\NormalTok{xopen "output.pdf"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clip}}{clip}}\label{clip}

\texttt{clip} (aliases \texttt{clipboard}, \texttt{pbcopy}) copies text
to the system clipboard (\texttt{pbcopy} on macOS,
\texttt{xclip}/\texttt{xsel} on Linux). Returns the text unchanged for
pipeline chaining. This is the missing link between generating output
and sharing it --- pipe any serializer\textquotesingle s output through
\texttt{clip} and paste directly into Slack, GitHub, docs, or email.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fr |\textgreater{} map +\{name =\textgreater{} \_, size =\textgreater{} format\_bytes(size)\} |\textgreater{} tmd |\textgreater{} clip   \# markdown table → clipboard}
\NormalTok{qw(a b c) |\textgreater{} join "," |\textgreater{} clip |\textgreater{} p                                  \# also prints}
\NormalTok{"some text" |\textgreater{} clip                                                  \# just copy}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{paste}}{paste}}\label{paste}

\texttt{paste} (alias \texttt{pbpaste}) reads text from the system
clipboard (\texttt{pbpaste} on macOS, \texttt{xclip}/\texttt{xsel} on
Linux). Returns the clipboard contents as a string, ready for pipeline
processing.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p paste                              \# print clipboard contents}
\NormalTok{paste |\textgreater{} lines |\textgreater{} grep /error/i |\textgreater{} p  \# search clipboard for errors}
\NormalTok{paste |\textgreater{} wc |\textgreater{} p                      \# word count of clipboard}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_table}}{to\_table}}\label{to_table}

\texttt{to\_table} (aliases \texttt{table}, \texttt{tbl}) 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 \texttt{freq} → \texttt{tbl}
expectations. The output is fixed-width text suitable for terminal
display, log files, or any monospace context.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @r = (\{name =\textgreater{} "Alice", age =\textgreater{} 30\}, \{name =\textgreater{} "Bob", age =\textgreater{} 25\})}
\NormalTok{@r |\textgreater{} tbl |\textgreater{} p}
\NormalTok{\# ┌───────┬─────┐}
\NormalTok{\# │ name  │ age │}
\NormalTok{\# ├───────┼─────┤}
\NormalTok{\# │ Alice │ 30  │}
\NormalTok{\# │ Bob   │ 25  │}
\NormalTok{\# └───────┴─────┘}
\NormalTok{fr |\textgreater{} map +\{name =\textgreater{} \_, size =\textgreater{} format\_bytes(size)\} |\textgreater{} tbl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sparkline}}{sparkline}}\label{sparkline}

\texttt{sparkline} (alias \texttt{spark}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{(3,7,1,9,4,2,8,5) |\textgreater{} spark |\textgreater{} p   \# ▃▆▁█▄▂▇▅}
\NormalTok{@daily\_sales |\textgreater{} spark |\textgreater{} p         \# quick trend line}
\NormalTok{fr |\textgreater{} map \{ size \} |\textgreater{} spark |\textgreater{} p   \# file size distribution}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bar\_chart}}{bar\_chart}}\label{bar_chart}

\texttt{bar\_chart} (alias \texttt{bars}) 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 \texttt{freq} for instant word/event counting visualization.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{qw(a b a c a b) |\textgreater{} freq |\textgreater{} bars |\textgreater{} p}
\NormalTok{\# a │ ████████████████████████████████████████ 3}
\NormalTok{\# b │ ███████████████████████████ 2}
\NormalTok{\# c │ █████████████ 1}
\NormalTok{bars(\{cpu =\textgreater{} 73, mem =\textgreater{} 45, disk =\textgreater{} 91\}) |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flame}}{flame}}\label{flame}

\texttt{flame} (alias \texttt{flamechart}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{flame(\{main =\textgreater{} \{parse =\textgreater{} 30, eval =\textgreater{} \{compile =\textgreater{} 15, run =\textgreater{} 45\}\}, init =\textgreater{} 10\}) |\textgreater{} p}
\NormalTok{my $profile = read\_json "profile.json"}
\NormalTok{flame($profile) |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{histo}}{histo}}\label{histo}

\texttt{histo} 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 \texttt{freq} for categorical data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{qw(a b a c a b) |\textgreater{} freq |\textgreater{} histo |\textgreater{} p   \# vertical bars for a/b/c}
\NormalTok{(map \{ int(rand(100)) \} 1:1000) |\textgreater{} histo |\textgreater{} p  \# distribution of randoms}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauge}}{gauge}}\label{gauge}

\texttt{gauge} 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:
\texttt{gauge(45,\ 100)}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gauge(0.73)       \# [██████████████████████░░░░░░░░] 73\%}
\NormalTok{p gauge(45, 100)    \# [█████████████░░░░░░░░░░░░░░░░] 45\%}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spinner}}{spinner}}\label{spinner}

\texttt{spinner} shows an animated braille spinner on stderr while a
block executes, then clears the spinner and returns the
block\textquotesingle s result. Useful for long-running one-liners where
you want visual feedback without polluting stdout.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $r = spinner "loading" \{ fetch\_json("https://api.example.com/data") \}}
\NormalTok{spinner \{ sleep 2}
\NormalTok{    42 \}   \# default message "working"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csv\_read}}{csv\_read}}\label{csv_read}

\texttt{csv\_read} (alias \texttt{cr}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @rows = csv\_read "data.csv"}
\NormalTok{p $rows[0]             \# first row as arrayref}
\NormalTok{@rows |\textgreater{} e \{ p \_{-}\textgreater{}[0] \}  \# print first column}
\NormalTok{my @inline = csv\_read "a,b,c\textbackslash{}n1,2,3\textbackslash{}n4,5,6"}
\NormalTok{p scalar @inline       \# 3 rows (including header)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csv\_write}}{csv\_write}}\label{csv_write}

\texttt{csv\_write} (alias \texttt{cw}) 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 \texttt{csv\_read} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @data = (["name", "age"], ["Alice", 30], ["Bob", 25])}
\NormalTok{csv\_write(\textbackslash{}@data) |\textgreater{} spurt "people.csv"}
\NormalTok{my @report = map \{ [\_{-}\textgreater{}\{id\}, \_{-}\textgreater{}\{score\}] \} @results}
\NormalTok{p csv\_write \textbackslash{}@report}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dataframe}}{dataframe}}\label{dataframe}

\texttt{dataframe} (alias \texttt{df}) 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\textquotesingle s answer to Python\textquotesingle s pandas
DataFrame --- lightweight but sufficient for common data manipulation
tasks.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $df = df [\{name =\textgreater{} "Alice", age =\textgreater{} 30\}, \{name =\textgreater{} "Bob", age =\textgreater{} 25\}]}
\NormalTok{p $df}
\NormalTok{my $df2 = df csv\_read "data.csv"}
\NormalTok{my @ages = $df{-}\textgreater{}\{age\}}
\NormalTok{p @ages   \# 30, 25}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sqlite}}{sqlite}}\label{sqlite}

\texttt{sqlite} (alias \texttt{sql}) 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 \texttt{sqlite} a zero-setup embedded
database.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{sqlite("app.db", "CREATE TABLE users (name TEXT, age INT)")}
\NormalTok{sqlite("app.db", "INSERT INTO users VALUES (?, ?)", "Alice", 30)}
\NormalTok{my @rows = sqlite("app.db", "SELECT * FROM users WHERE age \textgreater{} ?", 20)}
\NormalTok{@rows |\textgreater{} e \{ p \_{-}\textgreater{}\{name\} \}}
\NormalTok{sqlite("app.db", "SELECT count(*) as n FROM users") |\textgreater{} dd}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digits}}{digits}}\label{digits}

\texttt{digits} (alias \texttt{dg}) 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
\texttt{join} to reconstruct the numeric string, or \texttt{freq} for
digit distribution analysis.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p join "", digits("phone: 555{-}1234")     \# 5551234}
\NormalTok{"abc123def456" |\textgreater{} digits |\textgreater{} cnt |\textgreater{} p     \# 6}
\NormalTok{cat("log.txt") |\textgreater{} digits |\textgreater{} freq |\textgreater{} bars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{letters}}{letters}}\label{letters}

\texttt{letters} (alias \texttt{lts}) extracts all alphabetic characters
from a string and returns them as a list. Filters out digits,
punctuation, whitespace --- keeps only letters.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p join "", letters("h3ll0 w0rld!")   \# hllwrld}
\NormalTok{"abc123DEF" |\textgreater{} letters |\textgreater{} cnt |\textgreater{} p   \# 6}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sentences}}{sentences}}\label{sentences}

\texttt{sentences} (alias \texttt{sents}) splits text on sentence
boundaries (\texttt{.} \texttt{!} \texttt{?} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{"Hello world. How are you? Fine!" |\textgreater{} sentences |\textgreater{} e p}
\NormalTok{\# Hello world.}
\NormalTok{\# How are you?}
\NormalTok{\# Fine!}
\NormalTok{cat("essay.txt") |\textgreater{} sentences |\textgreater{} cnt |\textgreater{} p    \# sentence count}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{paragraphs}}{paragraphs}}\label{paragraphs}

\texttt{paragraphs} (alias \texttt{paras}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{cat("README.md") |\textgreater{} paragraphs |\textgreater{} cnt |\textgreater{} p   \# paragraph count}
\NormalTok{cat("essay.txt") |\textgreater{} paragraphs |\textgreater{} map \{ sentences |\textgreater{} cnt \} |\textgreater{} spark |\textgreater{} p  \# sentences per paragraph}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sections}}{sections}}\label{sections}

\texttt{sections} (alias \texttt{sects}) splits text on markdown-style
headers (\texttt{\#\ ...}, \texttt{\#\#\ ...}) or lines of
\texttt{===}/\texttt{-\/-\/-}. Returns a list of arrayrefs
\texttt{{[}heading,\ body{]}} where each section\textquotesingle s
heading and body are separated. Useful for parsing structured documents.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{cat("README.md") |\textgreater{} sections |\textgreater{} cnt |\textgreater{} p     \# section count}
\NormalTok{cat("README.md") |\textgreater{} sections |\textgreater{} map \{ \_{-}\textgreater{}[0] \} |\textgreater{} e p  \# list all headings}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{numbers}}{numbers}}\label{numbers}

\texttt{numbers} (alias \texttt{nums}) extracts all numbers (integers
and floats, including negatives) from a string and returns them as
numeric values. Unlike \texttt{digits} which returns individual digit
characters, \texttt{numbers} returns actual parsed values. Useful for
pulling measurements, scores, or IDs out of mixed text.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p join ",", numbers("temp 98.6F, {-}20C, ver 3")  \# 98.6,{-}20,3}
\NormalTok{cat("log.txt") |\textgreater{} numbers |\textgreater{} avg |\textgreater{} p              \# average of all numbers in file}
\NormalTok{"price: $12.99 qty: 5" |\textgreater{} numbers |\textgreater{} e p            \# 12.99, 5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graphemes}}{graphemes}}\label{graphemes}

\texttt{graphemes} (alias \texttt{grs}) splits a string into Unicode
grapheme clusters. Unlike \texttt{chars} which splits on code points,
\texttt{graphemes} keeps combining marks and emoji sequences together as
single visual units. \texttt{"cafe\textbackslash{}u\{0301\}"} gives 4
graphemes (not 5 code points). Essential for correct text processing of
accented characters, emoji, and non-Latin scripts.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cnt graphemes("cafe\textbackslash{}u\{0301\}")    \# 4 (not 5)}
\NormalTok{graphemes("hello") |\textgreater{} e p          \# h, e, l, l, o}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{columns}}{columns}}\label{columns}

\texttt{columns} (alias \texttt{cols}) splits fixed-width columnar text
into fields. Without a widths argument, it auto-detects columns by
splitting on runs of 2+ whitespace (ideal for \texttt{ps\ aux},
\texttt{ls\ -l}, \texttt{df} output). With an arrayref of widths, it
splits at exact fixed positions. Pairs with \texttt{lines} for
processing tabular command output.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @fields = columns("USER  PID  \%CPU")             \# auto{-}detect: [USER, PID, \%CPU]}
\NormalTok{my @fixed = columns("John   Doe   30", [7, 7, 3])   \# fixed{-}width: [John, Doe, 30]}
\NormalTok{capture("ps aux") |\textgreater{} lines |\textgreater{} map \{ columns \} |\textgreater{} tbl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stringify}}{stringify}}\label{stringify}

\texttt{stringify} (alias \texttt{str}) 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 \texttt{eval} 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 \texttt{dd},
which targets human readability, \texttt{str} prioritizes parseability.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = str \{a =\textgreater{} 1, b =\textgreater{} [2, 3]\}}
\NormalTok{p $s               \# \{a =\textgreater{} 1, b =\textgreater{} [2, 3]\}}
\NormalTok{my $copy = eval $s \# round{-}trip back to hashref}
\NormalTok{my @list = (1, "hello", undef)}
\NormalTok{p str \textbackslash{}@list        \# [1, "hello", undef]}
\end{Highlighting}
\end{Shaded}

Note: references are serialized recursively; circular references will
cause infinite recursion.

\section{\texorpdfstring{\texttt{ddump}}{ddump}}\label{ddump}

\texttt{ddump} (alias \texttt{dd}) 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 \texttt{dd} call anywhere in a pipeline to
inspect intermediate values without disrupting the data flow. The output
is colorized when stderr is a terminal. Unlike \texttt{str}, the output
is not meant for \texttt{eval} round-tripping; it prioritizes clarity
over parseability. \texttt{dd} returns its argument unchanged, so it can
be inserted into pipelines transparently.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%h = (name =\textgreater{} "Alice", scores =\textgreater{} [98, 87, 95])}
\NormalTok{dd \textbackslash{}\%h                        \# pretty{-}prints to stderr}
\NormalTok{my @result = @data |\textgreater{} dd |\textgreater{} grep \{ \_{-}\textgreater{}\{active\} \} |\textgreater{} dd}
\NormalTok{dd [1, \{a =\textgreater{} 2\}, [3, 4]]     \# nested structure}
\end{Highlighting}
\end{Shaded}

Note: \texttt{dd} writes to stderr, not stdout, so it never contaminates
pipeline output.

\section{\texorpdfstring{\texttt{toml\_decode}}{toml\_decode}}\label{toml_decode}

\texttt{toml\_decode} (alias \texttt{td}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cfg = toml\_decode(slurp "config.toml")}
\NormalTok{p $cfg{-}\textgreater{}\{database\}\{host\}   \# localhost}
\NormalTok{my $cargo = toml\_decode(slurp "Cargo.toml")}
\NormalTok{p $cargo{-}\textgreater{}\{package\}\{version\}}
\NormalTok{slurp("settings.toml") |\textgreater{} toml\_decode |\textgreater{} dd}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{toml\_encode}}{toml\_encode}}\label{toml_encode}

\texttt{toml\_encode} (alias \texttt{te}) serializes a stryke hashref
into a valid TOML string. Nested hashes become TOML sections with
\texttt{{[}section{]}} headers, arrays become TOML arrays, and scalars
are serialized with appropriate quoting. This is the inverse of
\texttt{toml\_decode} and is useful for generating or updating
configuration files programmatically. The output is human-readable and
can be written directly to a \texttt{.toml} file.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%cfg = (server =\textgreater{} \{host =\textgreater{} "0.0.0.0", port =\textgreater{} 8080\}, debug =\textgreater{} 0)}
\NormalTok{toml\_encode(\textbackslash{}\%cfg) |\textgreater{} spurt "server.toml"}
\NormalTok{my $round = toml\_decode(toml\_encode(\textbackslash{}\%cfg))}
\NormalTok{p $round{-}\textgreater{}\{server\}\{port\}  \# 8080}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yaml\_decode}}{yaml\_decode}}\label{yaml_decode}

\texttt{yaml\_decode} (alias \texttt{yd}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cfg = yaml\_decode(slurp "docker{-}compose.yml")}
\NormalTok{p $cfg{-}\textgreater{}\{services\}\{web\}\{image\}}
\NormalTok{my $ci = yaml\_decode(slurp ".github/workflows/ci.yml")}
\NormalTok{dd $ci{-}\textgreater{}\{jobs\}}
\NormalTok{slurp("values.yaml") |\textgreater{} yaml\_decode |\textgreater{} json\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yaml\_encode}}{yaml\_encode}}\label{yaml_encode}

\texttt{yaml\_encode} (alias \texttt{ye}) 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 \texttt{yaml\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%svc = (name =\textgreater{} "api", replicas =\textgreater{} 3, ports =\textgreater{} [80, 443])}
\NormalTok{yaml\_encode(\textbackslash{}\%svc) |\textgreater{} spurt "service.yaml"}
\NormalTok{my $round = yaml\_decode(yaml\_encode(\textbackslash{}\%svc))}
\NormalTok{p $round{-}\textgreater{}\{replicas\}   \# 3}
\NormalTok{rj("config.json") |\textgreater{} yaml\_encode |\textgreater{} p  \# JSON to YAML}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xml\_decode}}{xml\_decode}}\label{xml_decode}

\texttt{xml\_decode} (alias \texttt{xd}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $doc = xml\_decode(\textquotesingle{}\textless{}root\textgreater{}\textless{}name\textgreater{}stryke\textless{}/name\textgreater{}\textless{}ver\textgreater{}1\textless{}/ver\textgreater{}\textless{}/root\textgreater{}\textquotesingle{})}
\NormalTok{p $doc{-}\textgreater{}\{root\}\{name\}   \# stryke}
\NormalTok{slurp("feed.xml") |\textgreater{} xml\_decode |\textgreater{} dd}
\NormalTok{my $svg = xml\_decode(fetch("https://example.com/image.svg"))}
\NormalTok{p $svg{-}\textgreater{}\{svg\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xml\_encode}}{xml\_encode}}\label{xml_encode}

\texttt{xml\_encode} (alias \texttt{xe}) 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 \texttt{xml\_decode} and
round-trips cleanly.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%data = (root =\textgreater{} \{title =\textgreater{} "Test", items =\textgreater{} [\{id =\textgreater{} 1\}, \{id =\textgreater{} 2\}]\})}
\NormalTok{p xml\_encode \textbackslash{}\%data}
\NormalTok{xml\_encode(\textbackslash{}\%data) |\textgreater{} spurt "output.xml"}
\NormalTok{my $payload = xml\_encode \{request =\textgreater{} \{action =\textgreater{} "query", id =\textgreater{} 42\}\}}
\NormalTok{http\_request(method =\textgreater{} "POST", url =\textgreater{} $endpoint, body =\textgreater{} $payload)}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-http-networking}
\chapter{HTTP \& Networking}\label{http-networking}

23 topics

\section{\texorpdfstring{\texttt{fetch}}{fetch}}\label{fetch}

\texttt{fetch} (alias \texttt{ft}) 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 \texttt{fetch\_json} which additionally
decodes the response.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $html = fetch "https://example.com"}
\NormalTok{p $html}
\NormalTok{my $ip = fetch "https://api.ipify.org"}
\NormalTok{p "My IP: $ip"}
\NormalTok{fetch("https://example.com/data.txt") |\textgreater{} spurt "local.txt"$1}

\NormalTok{Note: for POST, PUT, DELETE, or custom headers, use \textasciigrave{}http\_request\textasciigrave{} instead.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fetch\_json}}{fetch\_json}}\label{fetch_json}

\texttt{fetch\_json} (alias \texttt{ftj}) performs a blocking HTTP GET
request and automatically decodes the JSON response body into a stryke
data structure. This combines \texttt{fetch} and \texttt{json\_decode}
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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $data = fetch\_json "https://api.github.com/repos/stryke/stryke"}
\NormalTok{p $data{-}\textgreater{}\{stargazers\_count\}}
\NormalTok{fetch\_json("https://jsonplaceholder.typicode.com/todos") |\textgreater{} e \{ p \_{-}\textgreater{}\{title\} \}}
\NormalTok{my $weather = fetch\_json "https://wttr.in/?format=j1"}
\NormalTok{p $weather{-}\textgreater{}\{current\_condition\}[0]\{temp\_C\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fetch\_async}}{fetch\_async}}\label{fetch_async}

\texttt{fetch\_async} (alias \texttt{fta}) 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 \texttt{fetch}. Use this when you need to parallelize
network I/O without threads.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $t1 = fetch\_async "https://api.example.com/users"}
\NormalTok{my $t2 = fetch\_async "https://api.example.com/posts"}
\NormalTok{my $users = await $t1}
\NormalTok{my $posts = await $t2}
\NormalTok{p "Got users and posts concurrently"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fetch\_async\_json}}{fetch\_async\_json}}\label{fetch_async_json}

\texttt{fetch\_async\_json} (alias \texttt{ftaj}) initiates a
non-blocking HTTP GET request that automatically decodes the JSON
response when awaited. This combines \texttt{fetch\_async} with
\texttt{json\_decode}, 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @urls = map \{ "https://api.example.com/item/$\_" \} 1:10}
\NormalTok{my @tasks = map fetch\_async\_json @urls}
\NormalTok{my @results = map await @tasks}
\NormalTok{@results |\textgreater{} e \{ p \_{-}\textgreater{}\{name\} \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{http\_request}}{http\_request}}\label{http_request}

\texttt{http\_request} (alias \texttt{hr}) performs a fully configurable
HTTP request with control over method, headers, body, and timeout.
Unlike \texttt{fetch} which is limited to GET, \texttt{http\_request}
supports POST, PUT, PATCH, DELETE, and any other HTTP method. Pass named
parameters for configuration. The response is returned as a hashref
containing \texttt{status}, \texttt{headers}, and \texttt{body} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $res = http\_request(method =\textgreater{} "POST", url =\textgreater{} "https://api.example.com/users",}
\NormalTok{    headers =\textgreater{} \{"Content{-}Type" =\textgreater{} "application/json", Authorization =\textgreater{} "Bearer $token"\},}
\NormalTok{    body =\textgreater{} tj \{name =\textgreater{} "Alice"\})}
\NormalTok{p $res{-}\textgreater{}\{status\}   \# 201}
\NormalTok{my $data = json\_decode $res{-}\textgreater{}\{body\}}
\NormalTok{my $del = http\_request(method =\textgreater{} "DELETE", url =\textgreater{} "https://api.example.com/users/42")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_fetch}}{par\_fetch}}\label{par_fetch}

\texttt{par\_fetch\ @urls} --- fetch a list of URLs in parallel using
async HTTP, returning an array of response bodies in input order.

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
\texttt{http\_request} inside \texttt{pmap} instead. \texttt{par\_fetch}
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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @bodies = par\_fetch @urls}

\NormalTok{\# Fetch and decode JSON in one shot:}
\NormalTok{my @data = par\_fetch(@api\_urls) |\textgreater{} map json\_decode}

\NormalTok{\# Download pages with progress:}
\NormalTok{my @pages = par\_fetch @urls, progress =\textgreater{} 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{serve}}{serve}}\label{serve}

Start a blocking HTTP server.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{serve 8080, fn ($req) \{}
\NormalTok{    \# $req = \{ method, path, query, headers, body, peer \}}
\NormalTok{    \{ status =\textgreater{} 200, body =\textgreater{} "hello" \}}
\NormalTok{\}}

\NormalTok{serve 3000, fn ($req) \{}
\NormalTok{    my $data = \{ name =\textgreater{} "stryke", version =\textgreater{} "0.4" \}}
\NormalTok{    \{ status =\textgreater{} 200, body =\textgreater{} json\_encode($data) \}}
\NormalTok{\}, \{ workers =\textgreater{} 8 \}$1}

\NormalTok{Handler returns: hashref \textasciigrave{}\{ status, body, headers \}\textasciigrave{}, string (200 OK), or undef (404).}
\NormalTok{JSON content{-}type auto{-}detected when body starts with \textasciigrave{}\{\textasciigrave{} or \textasciigrave{}[\textasciigrave{}.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{socket}}{socket}}\label{socket}

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 \texttt{bind}, \texttt{connect}, \texttt{send}, \texttt{recv}, and
other socket operations. Domain constants include \texttt{AF\_INET}
(IPv4) and \texttt{AF\_INET6} (IPv6); type constants include
\texttt{SOCK\_STREAM} (TCP) and \texttt{SOCK\_DGRAM} (UDP).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{socket(my $sock, AF\_INET, SOCK\_STREAM, 0)}
\NormalTok{my $addr = sockaddr\_in(8080, inet\_aton("127.0.0.1"))}
\NormalTok{connect($sock, $addr)}
\NormalTok{send($sock, "GET / HTTP/1.0\textbackslash{}r\textbackslash{}n\textbackslash{}r\textbackslash{}n", 0)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bind}}{bind}}\label{bind}

Bind a socket to a local address so it can accept connections or receive
datagrams on that address. The address is a packed \texttt{sockaddr\_in}
or \texttt{sockaddr\_in6} structure. Binding is required before calling
\texttt{listen} on a server socket. Dies if the address is already in
use unless \texttt{SO\_REUSEADDR} is set.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{socket(my $srv, AF\_INET, SOCK\_STREAM, 0)}
\NormalTok{setsockopt($srv, SOL\_SOCKET, SO\_REUSEADDR, 1)}
\NormalTok{bind($srv, sockaddr\_in(8080, INADDR\_ANY)) or die "bind: $!"}
\NormalTok{listen($srv, 5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{listen}}{listen}}\label{listen}

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 \texttt{accept} in a loop after
\texttt{listen} to handle clients.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{socket(my $srv, AF\_INET, SOCK\_STREAM, 0)}
\NormalTok{bind($srv, sockaddr\_in(9000, INADDR\_ANY))}
\NormalTok{listen($srv, 128) or die "listen: $!"}
\NormalTok{while (accept(my $client, $srv)) \{}
\NormalTok{    send($client, "hello\textbackslash{}n", 0)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{accept}}{accept}}\label{accept}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{listen($srv, 5)}
\NormalTok{while (my $remote = accept(my $client, $srv)) \{}
\NormalTok{    my ($port, $ip) = sockaddr\_in($remote)}
\NormalTok{    p "connection from " . inet\_ntoa($ip) . ":$port"}
\NormalTok{    send($client, "welcome\textbackslash{}n", 0)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{connect}}{connect}}\label{connect}

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 \texttt{send} calls do not need an address.
Dies or returns false if the connection is refused or times out.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{socket(my $sock, AF\_INET, SOCK\_STREAM, 0)}
\NormalTok{my $addr = sockaddr\_in(80, inet\_aton("example.com"))}
\NormalTok{connect($sock, $addr) or die "connect: $!"}
\NormalTok{send($sock, "GET / HTTP/1.0\textbackslash{}r\textbackslash{}n\textbackslash{}r\textbackslash{}n", 0)}
\NormalTok{recv($sock, my $buf, 4096, 0)}
\NormalTok{p $buf}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{send}}{send}}\label{send}

Send data through a connected socket. The flags argument controls
behavior --- use \texttt{0} for normal sends. For UDP sockets you can
supply a destination address as a fourth argument to send to a specific
peer without calling \texttt{connect} first. Returns the number of bytes
sent, or \texttt{undef} on error.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{send($sock, "hello world\textbackslash{}n", 0)}
\NormalTok{my $n = send($sock, $payload, 0)}
\NormalTok{p "sent $n bytes"}
\NormalTok{\# UDP to specific peer}
\NormalTok{send($udp, $msg, 0, sockaddr\_in(5000, inet\_aton("10.0.0.1")))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{recv}}{recv}}\label{recv}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{recv($sock, my $buf, 4096, 0) or die "recv: $!"}
\NormalTok{p $buf}
\NormalTok{my $data = ""}
\NormalTok{while (recv($sock, my $chunk, 8192, 0) \&\& length($chunk)) \{}
\NormalTok{    $data .= $chunk}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shutdown}}{shutdown}}\label{shutdown}

Shut down part or all of a socket connection without closing the file
descriptor. The \texttt{how} argument controls direction: \texttt{0}
stops reading, \texttt{1} stops writing (sends FIN to peer), \texttt{2}
stops both. This is useful for signaling end-of-data to the remote side
while still reading its response.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{send($sock, $request, 0)}
\NormalTok{shutdown($sock, 1)           \# done writing}
\NormalTok{recv($sock, my $resp, 65536, 0)  \# still read response}
\NormalTok{shutdown($sock, 2)           \# fully close}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setsockopt}}{setsockopt}}\label{setsockopt}

Set an option on a socket at the specified protocol level. Common uses
include enabling \texttt{SO\_REUSEADDR} to allow immediate rebinding
after a server restart, setting \texttt{TCP\_NODELAY} to disable
Nagle\textquotesingle s algorithm, or adjusting buffer sizes. The value
is typically a packed integer.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{setsockopt($srv, SOL\_SOCKET, SO\_REUSEADDR, 1)}
\NormalTok{setsockopt($sock, IPPROTO\_TCP, TCP\_NODELAY, 1)}
\NormalTok{setsockopt($sock, SOL\_SOCKET, SO\_RCVBUF, pack("I", 262144))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getsockopt}}{getsockopt}}\label{getsockopt}

Retrieve the current value of a socket option at the specified protocol
level. Returns the option value as a packed binary string --- use
\texttt{unpack} to interpret it. Useful for inspecting buffer sizes,
checking whether \texttt{SO\_REUSEADDR} is set, or reading OS-assigned
values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $val = getsockopt($sock, SOL\_SOCKET, SO\_RCVBUF)}
\NormalTok{p unpack("I", $val)                 \# e.g. 131072}
\NormalTok{my $reuse = getsockopt($srv, SOL\_SOCKET, SO\_REUSEADDR)}
\NormalTok{p unpack("I", $reuse)               \# 1 or 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getsockname}}{getsockname}}\label{getsockname}

Return the packed socket address of the local end of a socket. This is
useful when the socket was bound to \texttt{INADDR\_ANY} or port
\texttt{0} (OS-assigned) and you need to discover the actual address and
port the OS chose. Unpack the result with \texttt{sockaddr\_in}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bind($sock, sockaddr\_in(0, INADDR\_ANY))  \# OS picks port}
\NormalTok{my $local = getsockname($sock)}
\NormalTok{my ($port, $ip) = sockaddr\_in($local)}
\NormalTok{p "listening on port $port"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getpeername}}{getpeername}}\label{getpeername}

Return the packed socket address of the remote end of a connected
socket. Use \texttt{sockaddr\_in} or \texttt{sockaddr\_in6} to unpack it
into a port and IP address. This is how a server discovers which client
it is talking to after \texttt{accept}, or how a client confirms the
peer address after \texttt{connect}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $packed = getpeername($client)}
\NormalTok{my ($port, $ip) = sockaddr\_in($packed)}
\NormalTok{p "peer: " . inet\_ntoa($ip) . ":$port"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gethostbyname}}{gethostbyname}}\label{gethostbyname}

Resolve a hostname to its network addresses using the system resolver.
Returns \texttt{(\$name,\ \$aliases,\ \$addrtype,\ \$length,\ @addrs)}.
The addresses are packed binary --- pass them through
\texttt{inet\_ntoa} to get dotted-quad strings. This is the classic DNS
forward-lookup function.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @info = gethostbyname("example.com")}
\NormalTok{my @addrs = @info[4..$ \#info]}
\NormalTok{@addrs |\textgreater{} map inet\_ntoa |\textgreater{} e p}
\NormalTok{my $ip = inet\_ntoa((gethostbyname("localhost"))[4])}
\NormalTok{p $ip   \# 127.0.0.1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gethostbyaddr}}{gethostbyaddr}}\label{gethostbyaddr}

Perform a reverse DNS lookup --- given a packed binary IP address and
address family, return the hostname associated with that address.
Returns \texttt{(\$name,\ \$aliases,\ \$addrtype,\ \$length,\ @addrs)}
on success, or empty list if no PTR record exists.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $packed = inet\_aton("8.8.8.8")}
\NormalTok{my $name = (gethostbyaddr($packed, AF\_INET))[0]}
\NormalTok{p $name   \# dns.google}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getprotobyname}}{getprotobyname}}\label{getprotobyname}

Look up a network protocol by its name and return protocol information.
Returns \texttt{(\$name,\ \$aliases,\ \$proto\_number)}. The protocol
number is what you pass to \texttt{socket} as the protocol argument.
Common names include \texttt{tcp}, \texttt{udp}, and \texttt{icmp}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($name, $aliases, $proto) = getprotobyname("tcp")}
\NormalTok{p "$name = protocol $proto"   \# tcp = protocol 6}
\NormalTok{socket(my $raw, AF\_INET, SOCK\_RAW, (getprotobyname("icmp"))[2])}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getservbyname}}{getservbyname}}\label{getservbyname}

Look up a network service by its name and protocol, returning the port
number and related information. Returns
\texttt{(\$name,\ \$aliases,\ \$port,\ \$proto)}. The port is in host
byte order. This resolves well-known service names like \texttt{http},
\texttt{ssh}, or \texttt{smtp} to their port numbers portably.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($name, $aliases, $port) = getservbyname("http", "tcp")}
\NormalTok{p "$name =\textgreater{} port $port"         \# http =\textgreater{} port 80}
\NormalTok{my $ssh\_port = (getservbyname("ssh", "tcp"))[2]}
\NormalTok{p $ssh\_port                     \# 22}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-crypto-encoding}
\chapter{Crypto \& Encoding}\label{crypto-encoding}

133 topics

\section{\texorpdfstring{\texttt{sha256}}{sha256}}\label{sha256}

\texttt{sha256} (alias \texttt{s256}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha256 "hello world"   \# b94d27b9934d3e08...}
\NormalTok{my $checksum = sha256 slurp "release.tar.gz"}
\NormalTok{p $checksum}
\NormalTok{rl("passwords.txt") |\textgreater{} map sha256 |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sha224}}{sha224}}\label{sha224}

\texttt{sha224} (alias \texttt{s224}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha224 "hello world"   \# 2f05477fc24bb4fa...}
\NormalTok{my $h = sha224(tj \{key =\textgreater{} "value"\})}
\NormalTok{p $h}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sha384}}{sha384}}\label{sha384}

\texttt{sha384} (alias \texttt{s384}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha384 "hello world"   \# fdbd8e75a67f29f7...}
\NormalTok{my $sig = sha384(slurp "document.pdf")}
\NormalTok{spurt "document.pdf.sha384", $sig}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sha512}}{sha512}}\label{sha512}

\texttt{sha512} (alias \texttt{s512}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha512 "hello world"   \# 309ecc489c12d6eb...}
\NormalTok{my $hash = sha512(slurp "firmware.bin");}
\NormalTok{p $hash;}
\NormalTok{my @hashes = map \{ sha512 \} @files}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sha1}}{sha1}}\label{sha1}

\texttt{sha1} (alias \texttt{s1}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha1 "hello world"   \# 2aae6c35c94fcfb4...}
\NormalTok{my $git\_id = sha1("blob " . length($content) . "\textbackslash{}0" . $content)}
\NormalTok{p $git\_id$1}

\NormalTok{Note: prefer SHA{-}256 for any security{-}related use case.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crc32}}{crc32}}\label{crc32}

\texttt{crc32} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p crc32 "hello world"   \# 222957957}
\NormalTok{my $chk = crc32(slurp "archive.zip");}
\NormalTok{p sprintf "0x\%08x", $chk;  \# hex representation}
\NormalTok{my @checksums = map \{ crc32 \} @chunks}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmac\_sha256}}{hmac\_sha256}}\label{hmac_sha256}

\texttt{hmac\_sha256} (alias \texttt{hmac}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sig = hmac\_sha256 "request body", "my{-}secret{-}key"}
\NormalTok{p $sig}
\NormalTok{my $webhook\_sig = hmac("POST /hook\textbackslash{}n$body", $secret)}
\NormalTok{p $webhook\_sig eq $expected ? "valid" : "tampered"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blake2b}}{blake2b}}\label{blake2b}

\texttt{blake2b} (alias \texttt{b2b}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p blake2b "hello world"   \# 021ced8799...}
\NormalTok{my $hash = b2b(slurp "large{-}file.bin");}
\NormalTok{my @hashes = map \{ blake2b \} @messages}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blake2s}}{blake2s}}\label{blake2s}

\texttt{blake2s} (alias \texttt{b2s}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p blake2s "hello world"   \# 9aec6806...}
\NormalTok{my $checksum = b2s($firmware\_blob)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blake3}}{blake3}}\label{blake3}

\texttt{blake3} (alias \texttt{b3}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p blake3 "hello world"   \# d74981efa...}
\NormalTok{my $hash = b3(slurp "gigabyte{-}file.bin")  \# fast!}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argon2\_hash}}{argon2\_hash}}\label{argon2_hash}

\texttt{argon2\_hash} (alias \texttt{argon2}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $hash = argon2\_hash("user{-}password")}
\NormalTok{to\_file("user.hash", $hash)}
\NormalTok{\# later...}
\NormalTok{if (argon2\_verify("user{-}password", $hash)) \{}
\NormalTok{    p "login successful"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argon2\_verify}}{argon2\_verify}}\label{argon2_verify}

\texttt{argon2\_verify} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $stored = rl("user.hash")}
\NormalTok{if (argon2\_verify($user\_input, $stored)) \{}
\NormalTok{    p "access granted"}
\NormalTok{\} else \{}
\NormalTok{    p "invalid password"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bcrypt\_hash}}{bcrypt\_hash}}\label{bcrypt_hash}

\texttt{bcrypt\_hash} (alias \texttt{bcrypt}) hashes a password using
the bcrypt algorithm, returning a standard \texttt{\$2b\$...} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $hash = bcrypt\_hash("my{-}password")}
\NormalTok{p $hash  \# $2b$12$...}
\NormalTok{if (bcrypt\_verify("my{-}password", $hash)) \{}
\NormalTok{    p "correct"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bcrypt\_verify}}{bcrypt\_verify}}\label{bcrypt_verify}

\texttt{bcrypt\_verify} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (bcrypt\_verify($password, $stored\_hash)) \{}
\NormalTok{    grant\_access()}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scrypt\_hash}}{scrypt\_hash}}\label{scrypt_hash}

\texttt{scrypt\_hash} (alias \texttt{scrypt}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $hash = scrypt\_hash("password123")}
\NormalTok{if (scrypt\_verify("password123", $hash)) \{}
\NormalTok{    p "verified"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scrypt\_verify}}{scrypt\_verify}}\label{scrypt_verify}

\texttt{scrypt\_verify} verifies a password against a scrypt PHC hash.
Returns 1 on match, 0 otherwise.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (scrypt\_verify($input, $stored)) \{}
\NormalTok{    p "valid"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pbkdf2}}{pbkdf2}}\label{pbkdf2}

\texttt{pbkdf2} (alias \texttt{pbkdf2\_derive}) 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).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = pbkdf2("password", "random{-}salt")}
\NormalTok{p $key  \# 64 hex chars = 32 bytes}
\NormalTok{my $strong = pbkdf2("pass", $salt, 200\_000)  \# more iterations}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_bytes}}{random\_bytes}}\label{random_bytes}

\texttt{random\_bytes} (alias \texttt{randbytes}) 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 \texttt{rand()}
for cryptographic purposes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)   \# 256{-}bit key}
\NormalTok{my $nonce = random\_bytes(12) \# 96{-}bit nonce for AES{-}GCM}
\NormalTok{p hex\_encode($key)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_bytes\_hex}}{random\_bytes\_hex}}\label{random_bytes_hex}

\texttt{random\_bytes\_hex} (alias \texttt{randhex}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $token = random\_bytes\_hex(16)  \# 32 hex chars}
\NormalTok{p $token   \# 7a3f9b2c1d...}
\NormalTok{my $api\_key = "sk\_" . randhex(24)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aes\_encrypt}}{aes\_encrypt}}\label{aes_encrypt}

\texttt{aes\_encrypt} (alias \texttt{aes\_enc}) encrypts plaintext using
AES-256-GCM authenticated encryption. Takes a 32-byte key (use
\texttt{random\_bytes(32)} or \texttt{pbkdf2}). Returns a base64 string
containing the nonce and ciphertext. AES-GCM provides both
confidentiality and integrity --- tampering is detected on decryption.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)}
\NormalTok{my $cipher = aes\_encrypt($key, "secret message")}
\NormalTok{p $cipher  \# base64 encoded}
\NormalTok{my $plain = aes\_decrypt($key, $cipher)}
\NormalTok{p $plain   \# secret message}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aes\_decrypt}}{aes\_decrypt}}\label{aes_decrypt}

\texttt{aes\_decrypt} (alias \texttt{aes\_dec}) decrypts AES-256-GCM
ciphertext produced by \texttt{aes\_encrypt}. Takes the same 32-byte key
and the base64 ciphertext. Dies if the key is wrong or the ciphertext
was tampered with (authentication failure).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $plain = aes\_decrypt($key, $ciphertext)}
\NormalTok{p $plain}
\NormalTok{\# wrong key or tampered data raises exception}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chacha\_encrypt}}{chacha\_encrypt}}\label{chacha_encrypt}

\texttt{chacha\_encrypt} (alias \texttt{chacha\_enc}) encrypts plaintext
using ChaCha20-Poly1305 authenticated encryption. Takes a 32-byte key.
Returns base64(nonce \textbar\textbar{} ciphertext \textbar\textbar{}
tag). ChaCha20-Poly1305 is the modern alternative to AES-GCM --- faster
in software, constant-time, and used in TLS 1.3, WireGuard, and SSH.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)}
\NormalTok{my $cipher = chacha\_encrypt($key, "secret data")}
\NormalTok{my $plain = chacha\_decrypt($key, $cipher)}
\NormalTok{p $plain}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chacha\_decrypt}}{chacha\_decrypt}}\label{chacha_decrypt}

\texttt{chacha\_decrypt} (alias \texttt{chacha\_dec}) decrypts
ChaCha20-Poly1305 ciphertext. Takes the same 32-byte key and base64
ciphertext. Dies on wrong key or tampering.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $plain = chacha\_decrypt($key, $cipher)}
\NormalTok{p $plain}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ed25519\_keygen}}{ed25519\_keygen}}\label{ed25519_keygen}

\texttt{ed25519\_keygen} (alias \texttt{ed\_keygen}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($priv, $pub) = @\{ ed25519\_keygen() \}}
\NormalTok{p "Private: $priv"}
\NormalTok{p "Public:  $pub"}
\NormalTok{my $sig = ed25519\_sign($priv, "message")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ed25519\_sign}}{ed25519\_sign}}\label{ed25519_sign}

\texttt{ed25519\_sign} (alias \texttt{ed\_sign}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sig = ed25519\_sign($private\_key, "hello world")}
\NormalTok{p $sig   \# 128 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ed25519\_verify}}{ed25519\_verify}}\label{ed25519_verify}

\texttt{ed25519\_verify} (alias \texttt{ed\_verify}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (ed25519\_verify($pub, "hello world", $sig)) \{}
\NormalTok{    p "signature valid"}
\NormalTok{\} else \{}
\NormalTok{    p "FORGED!"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{x25519\_keygen}}{x25519\_keygen}}\label{x25519_keygen}

\texttt{x25519\_keygen} (alias \texttt{x\_keygen}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($my\_priv, $my\_pub) = @\{ x25519\_keygen() \}}
\NormalTok{\# send $my\_pub to peer, receive $their\_pub}
\NormalTok{my $shared = x25519\_dh($my\_priv, $their\_pub)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{x25519\_dh}}{x25519\_dh}}\label{x25519_dh}

\texttt{x25519\_dh} (alias \texttt{x\_dh}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $shared = x25519\_dh($my\_private, $their\_public)}
\NormalTok{my $key = hex\_decode(substr($shared, 0, 64))  \# use as AES key}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base64\_encode}}{base64\_encode}}\label{base64_encode}

\texttt{base64\_encode} (alias \texttt{b64e}) 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 \texttt{=} as needed. Use
\texttt{base64\_decode} to reverse the encoding.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $encoded = base64\_encode "hello world"}
\NormalTok{p $encoded   \# aGVsbG8gd29ybGQ=}
\NormalTok{my $img\_data = slurp "photo.png"}
\NormalTok{my $data\_uri = "data:image/png;base64," . base64\_encode($img\_data)}
\NormalTok{p base64\_decode(base64\_encode("round trip"))  \# round trip}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base64\_decode}}{base64\_decode}}\label{base64_decode}

\texttt{base64\_decode} (alias \texttt{b64d}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $decoded = base64\_decode "aGVsbG8gd29ybGQ="}
\NormalTok{p $decoded   \# hello world}
\NormalTok{my $img = base64\_decode($api\_response{-}\textgreater{}\{avatar\_b64\})}
\NormalTok{spurt "avatar.png", $img}
\NormalTok{my $json = base64\_decode($jwt\_parts[1])}
\NormalTok{dd json\_decode $json}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_encode}}{hex\_encode}}\label{hex_encode}

\texttt{hex\_encode} (alias \texttt{hxe}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hex\_encode "hello"   \# 68656c6c6f}
\NormalTok{my $raw = slurp "key.bin"}
\NormalTok{p hex\_encode $raw}
\NormalTok{my $color = hex\_encode chr(255) . chr(128) . chr(0)}
\NormalTok{p "\#$color"   \# \#ff8000}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_decode}}{hex\_decode}}\label{hex_decode}

\texttt{hex\_decode} (alias \texttt{hxd}) converts a hexadecimal string
back to its original bytes, interpreting every two hex characters as one
byte. This is the inverse of \texttt{hex\_encode} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $bytes = hex\_decode "68656c6c6f"}
\NormalTok{p $bytes   \# hello}
\NormalTok{my $key = hex\_decode $env\_hex\_key}
\NormalTok{my $mac = hmac\_sha256($data, hex\_decode($secret\_hex))}
\NormalTok{p hex\_decode(hex\_encode("round trip"))  \# round trip}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uuid}}{uuid}}\label{uuid}

\texttt{uuid} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $id = uuid()}
\NormalTok{p $id   \# e.g., 550e8400{-}e29b{-}41d4{-}a716{-}446655440000}
\NormalTok{my \%record = (id =\textgreater{} uuid(), name =\textgreater{} "Alice", created =\textgreater{} time)}
\NormalTok{my @ids = map \{ uuid() \} 1:10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jwt\_encode}}{jwt\_encode}}\label{jwt_encode}

\texttt{jwt\_encode} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $token = jwt\_encode(\{sub =\textgreater{} "user123", exp =\textgreater{} time + 3600\}, "my{-}secret")}
\NormalTok{p $token}
\NormalTok{my $admin = jwt\_encode(\{role =\textgreater{} "admin", iat =\textgreater{} time\}, $secret, "HS512")}
\NormalTok{\# send as Authorization header}
\NormalTok{http\_request(method =\textgreater{} "GET", url =\textgreater{} $api\_url,}
\NormalTok{    headers =\textgreater{} \{Authorization =\textgreater{} "Bearer $token"\})}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jwt\_decode}}{jwt\_decode}}\label{jwt_decode}

\texttt{jwt\_decode} 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 \texttt{exp} 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 \texttt{jwt\_decode\_unsafe}
in production.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $payload = jwt\_decode($token, "my{-}secret")}
\NormalTok{p $payload{-}\textgreater{}\{sub\}   \# user123}
\NormalTok{my $claims = jwt\_decode($bearer\_token, $secret)}
\NormalTok{if ($claims{-}\textgreater{}\{role\} eq "admin") \{}
\NormalTok{    p "admin access granted"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Note: raises an exception on expired tokens, invalid signatures, or
malformed input.

\section{\texorpdfstring{\texttt{jwt\_decode\_unsafe}}{jwt\_decode\_unsafe}}\label{jwt_decode_unsafe}

\texttt{jwt\_decode\_unsafe} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# debugging only — never use for auth}
\NormalTok{my $claims = jwt\_decode\_unsafe($token)}
\NormalTok{dd $claims}
\NormalTok{p $claims{-}\textgreater{}\{sub\}   \# inspect without needing the secret}
\NormalTok{my $exp = $claims{-}\textgreater{}\{exp\}}
\NormalTok{p "Expires: " . datetime\_from\_epoch($exp)$1}

\NormalTok{Note: this function exists for debugging. Use \textasciigrave{}jwt\_decode\textasciigrave{} with a secret for any security{-}relevant validation.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_encode}}{url\_encode}}\label{url_encode}

Percent-encode a string so it is safe to embed in a URL query parameter
or path segment. Unreserved characters (alphanumeric, \texttt{-},
\texttt{\_}, \texttt{.}, \texttt{\textasciitilde{}}) are left as-is;
everything else becomes \texttt{\%XX}. The alias \texttt{uri\_escape}
matches the classic \texttt{URI::Escape} name for Perl muscle-memory.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $q = "hello world \& friends"}
\NormalTok{my $safe = url\_encode($q)}
\NormalTok{p $safe   \# hello\%20world\%20\%26\%20friends}
\NormalTok{my $url = "https://example.com/search?q=" . url\_encode($q)}
\NormalTok{p $url$1}

\NormalTok{Note: does not encode the full URL structure — encode individual components, not the whole URL.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_decode}}{url\_decode}}\label{url_decode}

Decode a percent-encoded string back to its original form, converting
\texttt{\%XX} sequences to the corresponding bytes and \texttt{+} to
space. The alias \texttt{uri\_unescape} matches \texttt{URI::Escape}
conventions. Use this when parsing query strings from incoming URLs or
reading URL-encoded form data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $encoded = "hello\%20world\%20\%26\%20friends"}
\NormalTok{p url\_decode($encoded)   \# hello world \& friends}
\NormalTok{\# round{-}trip}
\NormalTok{my $orig = "café ☕"}
\NormalTok{p url\_decode(url\_encode($orig)) eq $orig  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gzip}}{gzip}}\label{gzip}

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 \texttt{gunzip} for
decompression. The compression level is chosen automatically for a good
speed/size tradeoff.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $raw = "hello world" x 1000}
\NormalTok{my $gz = gzip($raw)}
\NormalTok{to\_file("data.gz", $gz)}
\NormalTok{p length($gz)       \# much smaller than original}
\NormalTok{p gunzip($gz) eq $raw  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gunzip}}{gunzip}}\label{gunzip}

Decompress gzip-compressed data (RFC 1952) and return the original
bytes. Dies if the input is not valid gzip. Use this to read
\texttt{.gz} files or decompress data received from HTTP responses with
\texttt{Content-Encoding:\ gzip}. Always the inverse of \texttt{gzip}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = rl("archive.gz")}
\NormalTok{my $text = gunzip($compressed)}
\NormalTok{p $text}
\NormalTok{\# round{-}trip in a pipeline}
\NormalTok{"payload" |\textgreater{} gzip |\textgreater{} gunzip |\textgreater{} p  \# payload}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zstd}}{zstd}}\label{zstd}

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 \texttt{zstd\_decode} for
decompression.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $big = "x]" x 100\_000}
\NormalTok{my $compressed = zstd($big)}
\NormalTok{p length($compressed)  \# fraction of original}
\NormalTok{to\_file("data.zst", $compressed)}
\NormalTok{p zstd\_decode($compressed) eq $big  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zstd\_decode}}{zstd\_decode}}\label{zstd_decode}

Decompress Zstandard-compressed data and return the original bytes. Dies
if the input is not valid Zstandard. This is the inverse of
\texttt{zstd}. Use it to read \texttt{.zst} files or decompress cached
buffers that were compressed with \texttt{zstd}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $packed = zstd("important data\textbackslash{}n" x 500)}
\NormalTok{my $original = zstd\_decode($packed)}
\NormalTok{p $original}
\NormalTok{\# file round{-}trip}
\NormalTok{to\_file("cache.zst", zstd($payload))}
\NormalTok{p zstd\_decode(rl("cache.zst"))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sha3\_256}}{sha3\_256}}\label{sha3_256}

\texttt{sha3\_256} (alias \texttt{s3\_256}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha3\_256 "hello world"   \# 644bcc7e...}
\NormalTok{my $h = s3\_256(slurp "file.bin")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sha3\_512}}{sha3\_512}}\label{sha3_512}

\texttt{sha3\_512} (alias \texttt{s3\_512}) computes the SHA3-512 hash
and returns a 128-character hex string. Provides a 512-bit digest with
the SHA-3 sponge construction.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sha3\_512 "hello world"   \# 840006...}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shake128}}{shake128}}\label{shake128}

\texttt{shake128} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p shake128("seed", 32)   \# 64 hex chars (32 bytes)}
\NormalTok{p shake128("seed", 64)   \# 128 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shake256}}{shake256}}\label{shake256}

\texttt{shake256} is a SHA-3 XOF with higher security margin than
SHAKE128. Takes data and output length in bytes, returns hex.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p shake256("seed", 32)}
\NormalTok{p shake256("key material", 64)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ripemd160}}{ripemd160}}\label{ripemd160}

\texttt{ripemd160} (alias \texttt{rmd160}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ripemd160 "hello world"   \# 98c615784c...}
\NormalTok{my $hash160 = ripemd160(hex\_decode(sha256($pubkey)))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{siphash}}{siphash}}\label{siphash}

\texttt{siphash} 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\textquotesingle s fast and keyed, preventing
attackers from crafting collisions. Used in Rust\textquotesingle s
HashMap, Python dict, and many other hash tables.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p siphash "key"   \# 16 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmac\_sha1}}{hmac\_sha1}}\label{hmac_sha1}

\texttt{hmac\_sha1} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hmac\_sha1("secret", "message")   \# 40 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmac\_sha384}}{hmac\_sha384}}\label{hmac_sha384}

\texttt{hmac\_sha384} computes HMAC-SHA384 and returns a 96-character
hex string. Middle ground between SHA-256 and SHA-512.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hmac\_sha384("key", "data")   \# 96 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmac\_sha512}}{hmac\_sha512}}\label{hmac_sha512}

\texttt{hmac\_sha512} computes HMAC-SHA512 and returns a 128-character
hex string. Maximum security margin in the SHA-2 family.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hmac\_sha512("key", "data")   \# 128 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmac\_md5}}{hmac\_md5}}\label{hmac_md5}

\texttt{hmac\_md5} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hmac\_md5("key", "data")   \# 32 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hkdf\_sha256}}{hkdf\_sha256}}\label{hkdf_sha256}

\texttt{hkdf\_sha256} (alias \texttt{hkdf}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = hkdf("shared\_secret", "salt", "context", 32)  \# 64 hex}
\NormalTok{my $enc\_key = hex\_decode($key)  \# 32 bytes for AES{-}256}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hkdf\_sha512}}{hkdf\_sha512}}\label{hkdf_sha512}

\texttt{hkdf\_sha512} is HKDF using HMAC-SHA512. Higher security margin
than SHA256 variant.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = hkdf\_sha512("ikm", "salt", "info", 64)  \# 128 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poly1305}}{poly1305}}\label{poly1305}

\texttt{poly1305} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)}
\NormalTok{p poly1305($key, "message")   \# 32 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_keygen}}{rsa\_keygen}}\label{rsa_keygen}

\texttt{rsa\_keygen} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @kp = rsa\_keygen(2048)}
\NormalTok{my ($priv, $pub) = @kp}
\NormalTok{spurt("private.pem", $priv)}
\NormalTok{spurt("public.pem", $pub)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_encrypt}}{rsa\_encrypt}}\label{rsa_encrypt}

\texttt{rsa\_encrypt} (alias \texttt{rsa\_enc}) 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).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cipher = rsa\_encrypt($pub\_pem, "secret")}
\NormalTok{my $plain = rsa\_decrypt($priv\_pem, $cipher)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_decrypt}}{rsa\_decrypt}}\label{rsa_decrypt}

\texttt{rsa\_decrypt} (alias \texttt{rsa\_dec}) decrypts RSA-OAEP
ciphertext. Takes private\_key\_pem and base64 ciphertext.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $plain = rsa\_decrypt($priv, $ciphertext)}
\NormalTok{p $plain}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_sign}}{rsa\_sign}}\label{rsa_sign}

\texttt{rsa\_sign} signs a message with RSA-PKCS1v15-SHA256. Takes
private\_key\_pem and message. Returns base64 signature. This is the
RS256 algorithm used in JWT.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sig = rsa\_sign($priv, "message")}
\NormalTok{if (rsa\_verify($pub, "message", $sig)) \{}
\NormalTok{    p "valid"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_verify}}{rsa\_verify}}\label{rsa_verify}

\texttt{rsa\_verify} verifies an RSA-PKCS1v15-SHA256 signature. Takes
public\_key\_pem, message, and base64 signature. Returns 1 if valid, 0
if not.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (rsa\_verify($pub\_pem, $msg, $sig)) \{}
\NormalTok{    p "signature valid"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_p256\_keygen}}{ecdsa\_p256\_keygen}}\label{ecdsa_p256_keygen}

\texttt{ecdsa\_p256\_keygen} (alias \texttt{p256\_keygen}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @kp = ecdsa\_p256\_keygen()}
\NormalTok{my ($priv, $pub) = @kp}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_p256\_sign}}{ecdsa\_p256\_sign}}\label{ecdsa_p256_sign}

\texttt{ecdsa\_p256\_sign} (alias \texttt{p256\_sign}) signs a message
with ECDSA P-256. Takes private\_key\_hex and message. Returns
DER-encoded signature as hex.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sig = ecdsa\_p256\_sign($priv, "hello")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_p256\_verify}}{ecdsa\_p256\_verify}}\label{ecdsa_p256_verify}

\texttt{ecdsa\_p256\_verify} (alias \texttt{p256\_verify}) verifies an
ECDSA P-256 signature. Returns 1 if valid.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (ecdsa\_p256\_verify($pub, "hello", $sig)) \{}
\NormalTok{    p "valid"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_p384\_keygen}}{ecdsa\_p384\_keygen}}\label{ecdsa_p384_keygen}

\texttt{ecdsa\_p384\_keygen} generates an ECDSA P-384 keypair. P-384
offers more security margin than P-256.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @kp = ecdsa\_p384\_keygen()}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_p384\_sign}}{ecdsa\_p384\_sign}}\label{ecdsa_p384_sign}

\texttt{ecdsa\_p384\_sign} signs with ECDSA P-384.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sig = ecdsa\_p384\_sign($priv, $msg)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_p384\_verify}}{ecdsa\_p384\_verify}}\label{ecdsa_p384_verify}

\texttt{ecdsa\_p384\_verify} verifies an ECDSA P-384 signature.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ecdsa\_p384\_verify($pub, $msg, $sig)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_secp256k1\_keygen}}{ecdsa\_secp256k1\_keygen}}\label{ecdsa_secp256k1_keygen}

\texttt{ecdsa\_secp256k1\_keygen} generates an ECDSA secp256k1 keypair.
This is the Bitcoin/Ethereum curve --- different from P-256.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @kp = ecdsa\_secp256k1\_keygen()}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_secp256k1\_sign}}{ecdsa\_secp256k1\_sign}}\label{ecdsa_secp256k1_sign}

\texttt{ecdsa\_secp256k1\_sign} signs with ECDSA secp256k1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sig = ecdsa\_secp256k1\_sign($priv, $msg)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdsa\_secp256k1\_verify}}{ecdsa\_secp256k1\_verify}}\label{ecdsa_secp256k1_verify}

\texttt{ecdsa\_secp256k1\_verify} verifies an ECDSA secp256k1 signature.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ecdsa\_secp256k1\_verify($pub, $msg, $sig)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdh\_p256}}{ecdh\_p256}}\label{ecdh_p256}

\texttt{ecdh\_p256} (alias \texttt{p256\_dh}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @alice = ecdsa\_p256\_keygen()}
\NormalTok{my @bob = ecdsa\_p256\_keygen()}
\NormalTok{my $shared\_a = ecdh\_p256($alice[0], $bob[1])}
\NormalTok{my $shared\_b = ecdh\_p256($bob[0], $alice[1])}
\NormalTok{p $shared\_a eq $shared\_b  \# 1 — same secret}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdh\_p384}}{ecdh\_p384}}\label{ecdh_p384}

\texttt{ecdh\_p384} performs ECDH key exchange on P-384.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $shared = ecdh\_p384($my\_priv, $their\_pub)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base32\_encode}}{base32\_encode}}\label{base32_encode}

\texttt{base32\_encode} (alias \texttt{b32e}) encodes data as RFC 4648
Base32. Used in TOTP secrets, onion addresses, and Bech32. Returns
uppercase with padding.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p base32\_encode("hello")   \# NBSWY3DP}
\NormalTok{my $secret = base32\_encode(random\_bytes(20))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base32\_decode}}{base32\_decode}}\label{base32_decode}

\texttt{base32\_decode} (alias \texttt{b32d}) decodes RFC 4648 Base32
back to bytes. Accepts with or without padding.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p base32\_decode("NBSWY3DP")   \# hello}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base58\_encode}}{base58\_encode}}\label{base58_encode}

\texttt{base58\_encode} (alias \texttt{b58e}) encodes data using
Bitcoin\textquotesingle s Base58 alphabet (no 0, O, I, l to avoid
confusion). Used in Bitcoin addresses, IPFS CIDs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p base58\_encode("hello")   \# Cn8eVZg}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base58\_decode}}{base58\_decode}}\label{base58_decode}

\texttt{base58\_decode} (alias \texttt{b58d}) decodes Base58 back to
bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p base58\_decode("Cn8eVZg")   \# hello}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{totp}}{totp}}\label{totp}

\texttt{totp} (alias \texttt{totp\_generate}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $secret = base32\_encode(random\_bytes(20))}
\NormalTok{my $code = totp($secret)}
\NormalTok{p $code   \# 6{-}digit code}
\NormalTok{\# Custom: 8 digits, 60s period}
\NormalTok{my $code8 = totp($secret, 8, 60)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{totp\_verify}}{totp\_verify}}\label{totp_verify}

\texttt{totp\_verify} verifies a TOTP code with optional time window
(default ±1 period). Returns 1 if valid.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (totp\_verify($secret, $user\_code)) \{}
\NormalTok{    p "2FA valid"}
\NormalTok{\}}
\NormalTok{\# Wider window: ±2 periods}
\NormalTok{totp\_verify($secret, $code, 2)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hotp}}{hotp}}\label{hotp}

\texttt{hotp} (alias \texttt{hotp\_generate}) generates an HOTP code
(RFC 4226) using a counter. Takes base32 secret, counter value, optional
digits.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $code = hotp($secret, 42)  \# counter=42}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aes\_cbc\_encrypt}}{aes\_cbc\_encrypt}}\label{aes_cbc_encrypt}

\texttt{aes\_cbc\_encrypt} (alias \texttt{aes\_cbc\_enc}) encrypts with
AES-256-CBC and PKCS7 padding. Takes 32-byte key, plaintext, optional
16-byte IV (auto-generated if omitted). Returns base64(iv
\textbar\textbar{} ciphertext). Legacy mode --- prefer
\texttt{aes\_encrypt} (GCM) for new code.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)}
\NormalTok{my $ct = aes\_cbc\_encrypt($key, "secret")}
\NormalTok{my $pt = aes\_cbc\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aes\_cbc\_decrypt}}{aes\_cbc\_decrypt}}\label{aes_cbc_decrypt}

\texttt{aes\_cbc\_decrypt} (alias \texttt{aes\_cbc\_dec}) decrypts
AES-256-CBC. Takes 32-byte key and base64(iv \textbar\textbar{}
ciphertext).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = aes\_cbc\_decrypt($key, $ciphertext)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qr\_ascii}}{qr\_ascii}}\label{qr_ascii}

\texttt{qr\_ascii} (alias \texttt{qr}) generates a QR code as ASCII art.
Perfect for terminal output.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qr("https://example.com")}
\NormalTok{p qr("otpauth://totp/App:user?secret=$secret\&issuer=App")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qr\_png}}{qr\_png}}\label{qr_png}

\texttt{qr\_png} generates a QR code as PNG image data (base64 encoded).
Optional size parameter. Save to file or embed in HTML.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $png = qr\_png("https://example.com")}
\NormalTok{spurt("qr.png", base64\_decode($png))}
\NormalTok{\# Larger QR}
\NormalTok{my $big = qr\_png($url, 16)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qr\_svg}}{qr\_svg}}\label{qr_svg}

\texttt{qr\_svg} generates a QR code as SVG string. Scalable vector
graphics, ideal for web.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $svg = qr\_svg("https://example.com")}
\NormalTok{spurt("qr.svg", $svg)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{barcode\_code128}}{barcode\_code128}}\label{barcode_code128}

\texttt{barcode\_code128} (alias \texttt{code128}) generates a Code 128
barcode as ASCII. Code 128 supports alphanumeric data and is widely used
in shipping labels.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p code128("ABC{-}123")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{barcode\_code39}}{barcode\_code39}}\label{barcode_code39}

\texttt{barcode\_code39} (alias \texttt{code39}) generates a Code 39
barcode. Supports uppercase, digits, and some symbols. Used in
automotive and defense.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p code39("HELLO123")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{barcode\_ean13}}{barcode\_ean13}}\label{barcode_ean13}

\texttt{barcode\_ean13} (alias \texttt{ean13}) generates an EAN-13
barcode (European Article Number). Standard retail barcode --- requires
exactly 12-13 digits.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ean13("5901234123457")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{barcode\_svg}}{barcode\_svg}}\label{barcode_svg}

\texttt{barcode\_svg} generates a barcode as SVG. Second argument
specifies type: code128, code39, ean13, upca.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $svg = barcode\_svg("ABC{-}123", "code128")}
\NormalTok{spurt("barcode.svg", $svg)}
\NormalTok{my $retail = barcode\_svg("012345678905", "upca")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brotli}}{brotli}}\label{brotli}

\texttt{brotli} (alias \texttt{br}) compresses data using the Brotli
algorithm (RFC 7932). Excellent compression ratio, used in HTTP
compression. Returns compressed bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = brotli($data)}
\NormalTok{p length($data) . " {-}\textgreater{} " . length($compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brotli\_decode}}{brotli\_decode}}\label{brotli_decode}

\texttt{brotli\_decode} (alias \texttt{ubr}) decompresses Brotli data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $original = brotli\_decode($compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xz}}{xz}}\label{xz}

\texttt{xz} (alias \texttt{lzma}) compresses data using XZ/LZMA2. Best
compression ratio, slower. Returns compressed bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = xz($data)}
\NormalTok{spurt("file.xz", $compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xz\_decode}}{xz\_decode}}\label{xz_decode}

\texttt{xz\_decode} (aliases \texttt{unxz}, \texttt{unlzma})
decompresses XZ/LZMA data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $original = xz\_decode(slurp("file.xz"))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bzip2}}{bzip2}}\label{bzip2}

\texttt{bzip2} (alias \texttt{bz2}) compresses data using bzip2. Good
compression, moderate speed. Returns compressed bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = bzip2($data)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bzip2\_decode}}{bzip2\_decode}}\label{bzip2_decode}

\texttt{bzip2\_decode} (aliases \texttt{bunzip2}, \texttt{ubz2})
decompresses bzip2 data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $original = bunzip2($compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz4}}{lz4}}\label{lz4}

\texttt{lz4} compresses data using LZ4. Very fast
compression/decompression, moderate ratio. Ideal for real-time
compression.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = lz4($data)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz4\_decode}}{lz4\_decode}}\label{lz4_decode}

\texttt{lz4\_decode} (alias \texttt{unlz4}) decompresses LZ4 data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $original = lz4\_decode($compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snappy}}{snappy}}\label{snappy}

\texttt{snappy} (alias \texttt{snp}) compresses data using Snappy.
Fastest compression, used in databases and RPC. Returns compressed
bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = snappy($data)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snappy\_decode}}{snappy\_decode}}\label{snappy_decode}

\texttt{snappy\_decode} (alias \texttt{unsnappy}) decompresses Snappy
data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $original = snappy\_decode($compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzw}}{lzw}}\label{lzw}

\texttt{lzw} compresses data using LZW (GIF/TIFF style). Classic
algorithm.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $compressed = lzw($data)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzw\_decode}}{lzw\_decode}}\label{lzw_decode}

\texttt{lzw\_decode} (alias \texttt{unlzw}) decompresses LZW data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $original = lzw\_decode($compressed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_create}}{tar\_create}}\label{tar_create}

\texttt{tar\_create} (alias \texttt{tar}) creates a tar archive from a
directory. Returns tar bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $archive = tar\_create("./src")}
\NormalTok{spurt("backup.tar", $archive)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_extract}}{tar\_extract}}\label{tar_extract}

\texttt{tar\_extract} (alias \texttt{untar}) extracts a tar archive to a
directory.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{tar\_extract(slurp("backup.tar"), "./restored")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_list}}{tar\_list}}\label{tar_list}

\texttt{tar\_list} lists files in a tar archive. Returns array of paths.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @files = @\{tar\_list(slurp("backup.tar"))\}}
\NormalTok{@files |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_gz\_create}}{tar\_gz\_create}}\label{tar_gz_create}

\texttt{tar\_gz\_create} (alias \texttt{tgz}) creates a gzipped tar
archive. Convenience for tar + gzip.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $tgz = tgz("./project")}
\NormalTok{spurt("project.tar.gz", $tgz)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_gz\_extract}}{tar\_gz\_extract}}\label{tar_gz_extract}

\texttt{tar\_gz\_extract} (alias \texttt{untgz}) extracts a .tar.gz
archive.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{untgz(slurp("project.tar.gz"), "./extracted")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_create}}{zip\_create}}\label{zip_create}

\texttt{zip\_create} creates a ZIP archive from a directory. Returns zip
bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $archive = zip\_create("./docs")}
\NormalTok{spurt("docs.zip", $archive)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_extract}}{zip\_extract}}\label{zip_extract}

\texttt{zip\_extract} extracts a ZIP archive to a directory.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{zip\_extract(slurp("docs.zip"), "./extracted")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_list}}{zip\_list}}\label{zip_list}

\texttt{zip\_list} lists files in a ZIP archive. Returns array of paths.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @files = @\{zip\_list(slurp("archive.zip"))\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{md4}}{md4}}\label{md4}

\texttt{md4} computes the MD4 hash and returns a 32-character hex
string. MD4 is completely broken --- only use for legacy NTLM
compatibility or historical systems.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p md4("hello")   \# 32 hex chars}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xxh32}}{xxh32}}\label{xxh32}

\texttt{xxh32} (alias \texttt{xxhash32}) computes xxHash32 --- extremely
fast non-cryptographic hash. Optional seed parameter. Returns 8 hex
chars.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p xxh32("hello")        \# default seed 0}
\NormalTok{p xxh32("hello", 42)    \# with seed}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xxh64}}{xxh64}}\label{xxh64}

\texttt{xxh64} (alias \texttt{xxhash64}) computes xxHash64 --- fast
64-bit hash. Returns 16 hex chars.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p xxh64("hello")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xxh3}}{xxh3}}\label{xxh3}

\texttt{xxh3} (alias \texttt{xxhash3}) computes xxHash3-64 --- newest
xxHash variant, fastest on modern CPUs. Returns 16 hex chars.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p xxh3("hello")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xxh3\_128}}{xxh3\_128}}\label{xxh3_128}

\texttt{xxh3\_128} computes xxHash3-128. Returns 32 hex chars.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p xxh3\_128("hello")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{murmur3}}{murmur3}}\label{murmur3}

\texttt{murmur3} (alias \texttt{murmur3\_32}) computes MurmurHash3
32-bit. Fast non-cryptographic hash, widely used in hash tables and
bloom filters. Optional seed. Returns 8 hex chars.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p murmur3("hello")       \# default seed 0}
\NormalTok{p murmur3("hello", 42)   \# with seed}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{murmur3\_128}}{murmur3\_128}}\label{murmur3_128}

\texttt{murmur3\_128} computes MurmurHash3 128-bit (x64 variant).
Returns 32 hex chars.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p murmur3\_128("hello")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blowfish\_encrypt}}{blowfish\_encrypt}}\label{blowfish_encrypt}

\texttt{blowfish\_encrypt} (alias \texttt{bf\_enc}) encrypts with
Blowfish-CBC. Key=4-56 bytes, optional 8-byte IV. Legacy cipher --- use
AES for new code.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ct = blowfish\_encrypt($key, "secret")}
\NormalTok{my $pt = blowfish\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blowfish\_decrypt}}{blowfish\_decrypt}}\label{blowfish_decrypt}

\texttt{blowfish\_decrypt} (alias \texttt{bf\_dec}) decrypts
Blowfish-CBC.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = blowfish\_decrypt($key, $ciphertext)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{des3\_encrypt}}{des3\_encrypt}}\label{des3_encrypt}

\texttt{des3\_encrypt} (aliases \texttt{3des\_enc}, \texttt{tdes\_enc})
encrypts with Triple DES (3DES) CBC. Key=24 bytes (three 8-byte DES
keys). Legacy cipher for PCI-DSS compliance.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(24)}
\NormalTok{my $ct = des3\_encrypt($key, "secret")}
\NormalTok{my $pt = des3\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{des3\_decrypt}}{des3\_decrypt}}\label{des3_decrypt}

\texttt{des3\_decrypt} (aliases \texttt{3des\_dec}, \texttt{tdes\_dec})
decrypts Triple DES (3DES) CBC.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = des3\_decrypt($key, $ciphertext)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{twofish\_encrypt}}{twofish\_encrypt}}\label{twofish_encrypt}

\texttt{twofish\_encrypt} (alias \texttt{tf\_enc}) encrypts with
Twofish-CBC. Key=16/24/32 bytes. AES finalist, still secure.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)}
\NormalTok{my $ct = twofish\_encrypt($key, "secret")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{twofish\_decrypt}}{twofish\_decrypt}}\label{twofish_decrypt}

\texttt{twofish\_decrypt} (alias \texttt{tf\_dec}) decrypts Twofish-CBC.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = twofish\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{camellia\_encrypt}}{camellia\_encrypt}}\label{camellia_encrypt}

\texttt{camellia\_encrypt} (alias \texttt{cam\_enc}) encrypts with
Camellia-CBC. Key=16/24/32 bytes. Japanese/EU standard, equivalent
security to AES.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ct = camellia\_encrypt($key, "secret")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{camellia\_decrypt}}{camellia\_decrypt}}\label{camellia_decrypt}

\texttt{camellia\_decrypt} (alias \texttt{cam\_dec}) decrypts
Camellia-CBC.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = camellia\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cast5\_encrypt}}{cast5\_encrypt}}\label{cast5_encrypt}

\texttt{cast5\_encrypt} encrypts with CAST5-CBC. Key=5-16 bytes. Used in
PGP.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ct = cast5\_encrypt($key, "secret")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cast5\_decrypt}}{cast5\_decrypt}}\label{cast5_decrypt}

\texttt{cast5\_decrypt} decrypts CAST5-CBC.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = cast5\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{salsa20}}{salsa20}}\label{salsa20}

\texttt{salsa20} encrypts with Salsa20 stream cipher. Key=32 bytes,
nonce auto-generated. Fast, secure stream cipher.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ct = salsa20($key, "data")}
\NormalTok{my $pt = salsa20\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{salsa20\_decrypt}}{salsa20\_decrypt}}\label{salsa20_decrypt}

\texttt{salsa20\_decrypt} decrypts Salsa20.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = salsa20\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xsalsa20}}{xsalsa20}}\label{xsalsa20}

\texttt{xsalsa20} encrypts with XSalsa20 (extended 24-byte nonce). Safer
for random nonces.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ct = xsalsa20($key, "data")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xsalsa20\_decrypt}}{xsalsa20\_decrypt}}\label{xsalsa20_decrypt}

\texttt{xsalsa20\_decrypt} decrypts XSalsa20.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = xsalsa20\_decrypt($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{secretbox}}{secretbox}}\label{secretbox}

\texttt{secretbox} (alias \texttt{secretbox\_seal}) is
NaCl\textquotesingle s symmetric authenticated encryption
(XSalsa20-Poly1305). Key=32 bytes. Simple, secure, fast.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $key = random\_bytes(32)}
\NormalTok{my $ct = secretbox($key, "message")}
\NormalTok{my $pt = secretbox\_open($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{secretbox\_open}}{secretbox\_open}}\label{secretbox_open}

\texttt{secretbox\_open} decrypts and authenticates NaCl secretbox.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = secretbox\_open($key, $ct)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nacl\_box\_keygen}}{nacl\_box\_keygen}}\label{nacl_box_keygen}

\texttt{nacl\_box\_keygen} generates a NaCl box keypair (X25519).
Returns {[}secret\_key\_hex, public\_key\_hex{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @kp = nacl\_box\_keygen()}
\NormalTok{my ($sk, $pk) = @kp}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nacl\_box}}{nacl\_box}}\label{nacl_box}

\texttt{nacl\_box} is NaCl\textquotesingle s asymmetric authenticated
encryption. Takes recipient\textquotesingle s public key,
sender\textquotesingle s secret key, plaintext.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @alice = nacl\_box\_keygen()}
\NormalTok{my @bob = nacl\_box\_keygen()}
\NormalTok{my $ct = nacl\_box($bob[1], $alice[0], "hello")  \# to Bob from Alice}
\NormalTok{my $pt = nacl\_box\_open($alice[1], $bob[0], $ct)  \# Bob decrypts}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nacl\_box\_open}}{nacl\_box\_open}}\label{nacl_box_open}

\texttt{nacl\_box\_open} decrypts NaCl box. Takes
sender\textquotesingle s public key, recipient\textquotesingle s secret
key, ciphertext.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = nacl\_box\_open($sender\_pk, $my\_sk, $ct)}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-special-math-functions}
\chapter{Special Math Functions}\label{special-math-functions}

12 topics

\section{\texorpdfstring{\texttt{erf}}{erf}}\label{erf}

\texttt{erf} 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).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p erf(0)      \# 0}
\NormalTok{p erf(1)      \# 0.8427...}
\NormalTok{p erf(10)     \# \textasciitilde{}1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{erfc}}{erfc}}\label{erfc}

\texttt{erfc} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p erfc(0)     \# 1}
\NormalTok{p erfc(3)     \# 0.0000220...}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gamma}}{gamma}}\label{gamma}

\texttt{gamma} (alias \texttt{tgamma}) computes the gamma function Γ(x),
the extension of factorial to real numbers. Γ(n) = (n-1)! for positive
integers. Used throughout statistics, physics, and combinatorics.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gamma(5)    \# 24 (= 4!)}
\NormalTok{p gamma(0.5)  \# √π ≈ 1.7724...}
\NormalTok{p gamma(1)    \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lgamma}}{lgamma}}\label{lgamma}

\texttt{lgamma} (alias \texttt{ln\_gamma}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lgamma(100)  \# 359.13...}
\NormalTok{p lgamma(1000) \# 5905.22...}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digamma}}{digamma}}\label{digamma}

\texttt{digamma} (alias \texttt{psi}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p digamma(1)   \# {-}γ ≈ {-}0.5772 (Euler{-}Mascheroni)}
\NormalTok{p digamma(2)   \# 1 {-} γ ≈ 0.4228}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{beta\_fn}}{beta\_fn}}\label{beta_fn}

\texttt{beta\_fn} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p beta\_fn(2, 3)   \# 0.0833...}
\NormalTok{p beta\_fn(0.5, 0.5)  \# π}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lbeta}}{lbeta}}\label{lbeta}

\texttt{lbeta} (alias \texttt{ln\_beta}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lbeta(0.01, 0.01)  \# large positive}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{betainc}}{betainc}}\label{betainc}

\texttt{betainc} (alias \texttt{beta\_reg}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p betainc(0.5, 2, 3)  \# P(Beta(2,3) \textless{} 0.5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gammainc}}{gammainc}}\label{gammainc}

\texttt{gammainc} (alias \texttt{gamma\_li}) computes the lower
incomplete gamma function γ(a,x) = ∫₀ˣ t\^{}(a-1) e\^{}(-t) dt. Used in
computing CDFs of gamma and chi-squared distributions.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gammainc(2, 1)  \# γ(2, 1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gammaincc}}{gammaincc}}\label{gammaincc}

\texttt{gammaincc} (alias \texttt{gamma\_ui}) computes the upper
incomplete gamma function Γ(a,x) = ∫ₓ\^{}∞ t\^{}(a-1) e\^{}(-t) dt =
Γ(a) - γ(a,x). Useful for tail probabilities.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gammaincc(2, 1)  \# Γ(2, 1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gammainc\_reg}}{gammainc\_reg}}\label{gammainc_reg}

\texttt{gammainc\_reg} (alias \texttt{gamma\_lr}) computes the
regularized lower incomplete gamma P(a,x) = γ(a,x)/Γ(a), the CDF of the
gamma distribution Gamma(a, 1).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gammainc\_reg(2, 1)  \# P(Gamma(2,1) \textless{} 1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gammaincc\_reg}}{gammaincc\_reg}}\label{gammaincc_reg}

\texttt{gammaincc\_reg} (alias \texttt{gamma\_ur}) computes the
regularized upper incomplete gamma Q(a,x) = 1 - P(a,x), the survival
function of the gamma distribution.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gammaincc\_reg(2, 1)  \# P(Gamma(2,1) \textgreater{} 1)}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-bessel-airy-hankel-struve-kelvin}
\chapter{Bessel / Airy / Hankel / Struve /
Kelvin}\label{bessel-airy-hankel-struve-kelvin}

19 topics

\section{\texorpdfstring{\texttt{bessel\_j0}}{bessel\_j0}}\label{bessel_j0}

\texttt{bessel\_j0} (alias \texttt{j0}) computes the Bessel function of
the first kind, order 0.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p j0(0)    \# 1.0}
\NormalTok{p j0(2.4)  \# ≈ 0 (first zero)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_j1}}{bessel\_j1}}\label{bessel_j1}

\texttt{bessel\_j1} (alias \texttt{j1}) computes the Bessel function of
the first kind, order 1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p j1(0)    \# 0.0}
\NormalTok{p j1(1.84) \# ≈ 0.582 (first max)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_j}}{bessel\_j}}\label{bessel_j}

\texttt{bessel\_j\ N,\ X} --- Bessel function of the first kind J\_n(x)
for integer n. Generalises \texttt{bessel\_j0} / \texttt{bessel\_j1}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bessel\_j(2, 5)   \# ≈ 0.0466}
\NormalTok{p bessel\_j(0, 0)   \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_y}}{bessel\_y}}\label{bessel_y}

\texttt{bessel\_y\ N,\ X} --- Bessel function of the second kind
Y\_n(x). Singular at x = 0.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bessel\_y(0, 1)   \# ≈ 0.0883}
\NormalTok{p bessel\_y(1, 5)   \# ≈ 0.1479}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_i}}{bessel\_i}}\label{bessel_i}

\texttt{bessel\_i\ N,\ X} --- Modified Bessel function I\_n(x). Grows
exponentially for large x.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bessel\_i(0, 1)   \# ≈ 1.266}
\NormalTok{p bessel\_i(2, 3)   \# ≈ 2.245}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_k}}{bessel\_k}}\label{bessel_k}

\texttt{bessel\_k\ N,\ X} --- Modified Bessel function K\_n(x). Decays
exponentially for large x; singular at 0.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bessel\_k(0, 1)   \# ≈ 0.4210}
\NormalTok{p bessel\_k(1, 1)   \# ≈ 0.6019}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hankel\_h1}}{hankel\_h1}}\label{hankel_h1}

\texttt{hankel\_h1\ N,\ X} returns the complex Hankel H\_n\^{}(1)(x) =
J\_n(x) + i Y\_n(x) as \texttt{{[}Re,\ Im{]}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($re, $im) = hankel\_h1(0, 1)}
\NormalTok{p "$re + i*$im"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hankel\_h2}}{hankel\_h2}}\label{hankel_h2}

\texttt{hankel\_h2\ N,\ X} returns H\_n\^{}(2)(x) = J\_n(x) - i Y\_n(x)
as \texttt{{[}Re,\ Im{]}}.

\section{\texorpdfstring{\texttt{bessel\_j\_zero}}{bessel\_j\_zero}}\label{bessel_j_zero}

\texttt{bessel\_j\_zero\ N,\ K} computes the Kth positive zero of J\_n.
Uses McMahon expansion + Newton refinement.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bessel\_j\_zero(0, 1)  \# 2.4048…}
\NormalTok{p bessel\_j\_zero(1, 1)  \# 3.8317…}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{airy\_ai}}{airy\_ai}}\label{airy_ai}

\texttt{airy\_ai\ X} --- Airy function Ai(x) (decaying solution of
y\textquotesingle\textquotesingle{} = x y).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p airy\_ai(0)   \# ≈ 0.3550}
\NormalTok{p airy\_ai(2)   \# ≈ 0.0349}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{airy\_bi}}{airy\_bi}}\label{airy_bi}

\texttt{airy\_bi\ X} --- Airy function Bi(x) (growing solution).

\section{\texorpdfstring{\texttt{airy\_ai\_prime}}{airy\_ai\_prime}}\label{airy_ai_prime}

\texttt{airy\_ai\_prime\ X} --- derivative Ai\textquotesingle(x).

\section{\texorpdfstring{\texttt{airy\_bi\_prime}}{airy\_bi\_prime}}\label{airy_bi_prime}

\texttt{airy\_bi\_prime\ X} --- derivative Bi\textquotesingle(x).

\section{\texorpdfstring{\texttt{spherical\_bessel\_j}}{spherical\_bessel\_j}}\label{spherical_bessel_j}

\texttt{spherical\_bessel\_j\ N,\ X} --- j\_n(x) = √(π/2x)
J\_\{n+1/2\}(x).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p spherical\_bessel\_j(0, 1)  \# sin(1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_bessel\_y}}{spherical\_bessel\_y}}\label{spherical_bessel_y}

\texttt{spherical\_bessel\_y\ N,\ X} --- y\_n(x) = √(π/2x)
Y\_\{n+1/2\}(x).

\section{\texorpdfstring{\texttt{struve\_h}}{struve\_h}}\label{struve_h}

\texttt{struve\_h\ N,\ X} --- Struve function H\_n(x) (solution of an
inhomogeneous Bessel equation).

\section{\texorpdfstring{\texttt{struve\_l}}{struve\_l}}\label{struve_l}

\texttt{struve\_l\ N,\ X} --- Modified Struve L\_n(x).

\section{\texorpdfstring{\texttt{kelvin\_ber}}{kelvin\_ber}}\label{kelvin_ber}

\texttt{kelvin\_ber\ X} --- Real part of J\_0(x e\^{}(3πi/4)) (Kelvin
function ber₀).

\section{\texorpdfstring{\texttt{kelvin\_bei}}{kelvin\_bei}}\label{kelvin_bei}

\texttt{kelvin\_bei\ X} --- Imaginary part of J\_0(x e\^{}(3πi/4))
(Kelvin function bei₀).

\protect\phantomsection\label{ch-orthogonal-polynomials}
\chapter{Orthogonal Polynomials}\label{orthogonal-polynomials}

13 topics

\section{\texorpdfstring{\texttt{legendre\_p}}{legendre\_p}}\label{legendre_p}

\texttt{legendre\_p\ N,\ X} --- Legendre polynomial P\_n(x). Uses the
stable Bonnet recurrence (2n+1) x P\_n = (n+1) P\_\{n+1\} + n
P\_\{n-1\}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p legendre\_p(2, 0.5)  \# {-}0.125}
\NormalTok{p legendre\_p(5, 1)    \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{legendre\_q}}{legendre\_q}}\label{legendre_q}

\texttt{legendre\_q\ N,\ X} --- Legendre Q\_n(x), the second-kind
solution. NaN for \textbar x\textbar{} ≥ 1.

\section{\texorpdfstring{\texttt{assoc\_legendre\_p}}{assoc\_legendre\_p}}\label{assoc_legendre_p}

\texttt{assoc\_legendre\_p\ N,\ M,\ X} --- Associated Legendre
P\_n\^{}m(x). Building block for spherical harmonics.

\section{\texorpdfstring{\texttt{hermite\_h}}{hermite\_h}}\label{hermite_h}

\texttt{hermite\_h\ N,\ X} --- Physicist\textquotesingle s Hermite
H\_n(x): H\_0=1, H\_1=2x, H\_\{n+1\}=2x H\_n - 2n H\_\{n-1\}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hermite\_h(3, 1)   \# {-}4}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hermite\_he}}{hermite\_he}}\label{hermite_he}

\texttt{hermite\_he\ N,\ X} --- Probabilist\textquotesingle s Hermite
He\_n(x): He\_0=1, He\_1=x, He\_\{n+1\}=x He\_n - n He\_\{n-1\}.

\section{\texorpdfstring{\texttt{laguerre\_l}}{laguerre\_l}}\label{laguerre_l}

\texttt{laguerre\_l\ N,\ X} --- Laguerre polynomial L\_n(x).

\section{\texorpdfstring{\texttt{assoc\_laguerre\_l}}{assoc\_laguerre\_l}}\label{assoc_laguerre_l}

\texttt{assoc\_laguerre\_l\ N,\ ALPHA,\ X} --- Generalised Laguerre
L\_n\^{}α(x).

\section{\texorpdfstring{\texttt{jacobi\_p}}{jacobi\_p}}\label{jacobi_p}

\texttt{jacobi\_p\ N,\ ALPHA,\ BETA,\ X} --- Jacobi polynomial
P\_n\^{}\{(α,β)\}(x). Generalises Legendre/Chebyshev/Gegenbauer.

\section{\texorpdfstring{\texttt{gegenbauer\_c}}{gegenbauer\_c}}\label{gegenbauer_c}

\texttt{gegenbauer\_c\ N,\ ALPHA,\ X} --- Gegenbauer C\_n\^{}α(x).
Reduces to Chebyshev/Legendre at specific α.

\section{\texorpdfstring{\texttt{chebyshev\_t}}{chebyshev\_t}}\label{chebyshev_t}

\texttt{chebyshev\_t\ N,\ X} --- Chebyshev polynomial of the first kind
T\_n(x). Recurrence T\_\{n+1\} = 2x T\_n - T\_\{n-1\}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p chebyshev\_t(3, 0.5)   \# {-}0.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chebyshev\_u}}{chebyshev\_u}}\label{chebyshev_u}

\texttt{chebyshev\_u\ N,\ X} --- Chebyshev polynomial of the second kind
U\_n(x).

\section{\texorpdfstring{\texttt{spherical\_harmonic\_y}}{spherical\_harmonic\_y}}\label{spherical_harmonic_y}

\texttt{spherical\_harmonic\_y\ L,\ M,\ THETA,\ PHI} --- Spherical
harmonic Y\_l\^{}m(θ, φ) returned as \texttt{{[}Re,\ Im{]}}.

\section{\texorpdfstring{\texttt{zernike\_r}}{zernike\_r}}\label{zernike_r}

\texttt{zernike\_r\ N,\ M,\ R} --- Radial Zernike polynomial
R\_n\^{}m(r). 0 if (n − m) is odd or m \textgreater{} n.

\protect\phantomsection\label{ch-elliptic-integrals-functions}
\chapter{Elliptic Integrals \&
Functions}\label{elliptic-integrals-functions}

18 topics

\section{\texorpdfstring{\texttt{elliptic\_k}}{elliptic\_k}}\label{elliptic_k}

\texttt{elliptic\_k\ M} --- Complete elliptic integral K(m), m = k².
Computed via Carlson R\_F.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p elliptic\_k(0)    \# π/2}
\NormalTok{p elliptic\_k(0.5)  \# ≈ 1.8541}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elliptic\_e}}{elliptic\_e}}\label{elliptic_e}

\texttt{elliptic\_e\ M} --- Complete elliptic integral of the second
kind E(m).

\section{\texorpdfstring{\texttt{elliptic\_pi}}{elliptic\_pi}}\label{elliptic_pi}

\texttt{elliptic\_pi\ N,\ M} --- Complete elliptic integral of the third
kind Π(n \textbar{} m).

\section{\texorpdfstring{\texttt{elliptic\_f}}{elliptic\_f}}\label{elliptic_f}

\texttt{elliptic\_f\ PHI,\ M} --- Incomplete F(φ, m).

\section{\texorpdfstring{\texttt{elliptic\_e\_inc}}{elliptic\_e\_inc}}\label{elliptic_e_inc}

\texttt{elliptic\_e\_inc\ PHI,\ M} --- Incomplete E(φ, m).

\section{\texorpdfstring{\texttt{elliptic\_pi\_inc}}{elliptic\_pi\_inc}}\label{elliptic_pi_inc}

\texttt{elliptic\_pi\_inc\ N,\ PHI,\ M} --- Incomplete Π(n; φ \textbar{}
m).

\section{\texorpdfstring{\texttt{carlson\_rf}}{carlson\_rf}}\label{carlson_rf}

\texttt{carlson\_rf\ X,\ Y,\ Z} --- Carlson symmetric form R\_F.
Building block for the elliptic family.

\section{\texorpdfstring{\texttt{carlson\_rd}}{carlson\_rd}}\label{carlson_rd}

\texttt{carlson\_rd\ X,\ Y,\ Z} --- Carlson R\_D.

\section{\texorpdfstring{\texttt{carlson\_rj}}{carlson\_rj}}\label{carlson_rj}

\texttt{carlson\_rj\ X,\ Y,\ Z,\ P} --- Carlson R\_J.

\section{\texorpdfstring{\texttt{jacobi\_sn}}{jacobi\_sn}}\label{jacobi_sn}

\texttt{jacobi\_sn\ U,\ M} --- Jacobi elliptic sn(u, m). Reduces to
sin(u) at m = 0 and tanh(u) at m = 1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p jacobi\_sn(1, 0.5)  \# ≈ 0.8030}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jacobi\_cn}}{jacobi\_cn}}\label{jacobi_cn}

\texttt{jacobi\_cn\ U,\ M} --- Jacobi elliptic cn(u, m). Reduces to
cos(u) at m = 0.

\section{\texorpdfstring{\texttt{jacobi\_dn}}{jacobi\_dn}}\label{jacobi_dn}

\texttt{jacobi\_dn\ U,\ M} --- Jacobi elliptic dn(u, m). Reduces to 1 at
m = 0.

\section{\texorpdfstring{\texttt{jacobi\_am}}{jacobi\_am}}\label{jacobi_am}

\texttt{jacobi\_am\ U,\ M} --- Jacobi amplitude φ such that sn(u, m) =
sin(φ).

\section{\texorpdfstring{\texttt{elliptic\_theta}}{elliptic\_theta}}\label{elliptic_theta}

\texttt{elliptic\_theta\ J,\ Z,\ Q} --- Jacobi theta θ\_j(z, q) for j ∈
\{1, 2, 3, 4\}, \textbar q\textbar{} \textless{} 1.

\section{\texorpdfstring{\texttt{weierstrass\_p}}{weierstrass\_p}}\label{weierstrass_p}

\texttt{weierstrass\_p\ Z,\ G2,\ G3} --- Weierstrass ℘(z; g₂, g₃) via
Laurent series. Pole at z = 0.

\section{\texorpdfstring{\texttt{weierstrass\_zeta}}{weierstrass\_zeta}}\label{weierstrass_zeta}

\texttt{weierstrass\_zeta\ Z,\ G2,\ G3} --- Weierstrass ζ(z; g₂, g₃).

\section{\texorpdfstring{\texttt{weierstrass\_sigma}}{weierstrass\_sigma}}\label{weierstrass_sigma}

\texttt{weierstrass\_sigma\ Z,\ G2,\ G3} --- Weierstrass σ(z; g₂, g₃).

\section{\texorpdfstring{\texttt{inverse\_jacobi\_sn}}{inverse\_jacobi\_sn}}\label{inverse_jacobi_sn}

\texttt{inverse\_jacobi\_sn\ X,\ M} --- inverse of \texttt{jacobi\_sn}:
returns u with sn(u, m) = x.

\protect\phantomsection\label{ch-zeta-polylog-lerch}
\chapter{Zeta / Polylog / Lerch}\label{zeta-polylog-lerch}

9 topics

\section{\texorpdfstring{\texttt{zeta}}{zeta}}\label{zeta}

\texttt{zeta\ S} --- Riemann ζ(s) via Euler-Maclaurin (s \textgreater{}
0.5) or reflection identity.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p zeta(2)    \# π²/6 ≈ 1.6449}
\NormalTok{p zeta(4)    \# ≈ 1.0823}
\NormalTok{p zeta({-}1)   \# {-}1/12}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hurwitz\_zeta}}{hurwitz\_zeta}}\label{hurwitz_zeta}

\texttt{hurwitz\_zeta\ S,\ A} --- Hurwitz ζ(s, a).
\texttt{hurwitz\_zeta(s,\ 1)} ≡ \texttt{zeta(s)}.

\section{\texorpdfstring{\texttt{polylog}}{polylog}}\label{polylog}

\texttt{polylog\ N,\ Z} --- Polylogarithm Li\_n(z) = Σ z\^{}k / k\^{}n
for \textbar z\textbar{} ≤ 1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p polylog(2, 1)    \# π²/6}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dilog}}{dilog}}\label{dilog}

\texttt{dilog\ Z} --- Dilogarithm Li\_2(z). Convenience alias for
\texttt{polylog(2,\ z)}.

\section{\texorpdfstring{\texttt{lerch\_phi}}{lerch\_phi}}\label{lerch_phi}

\texttt{lerch\_phi\ Z,\ S,\ A} --- Lerch transcendent Φ(z, s, a) = Σ
z\^{}k / (a+k)\^{}s.

\section{\texorpdfstring{\texttt{riemann\_siegel\_z}}{riemann\_siegel\_z}}\label{riemann_siegel_z}

\texttt{riemann\_siegel\_z\ T} --- Riemann-Siegel Z(t) on the critical
line.

\section{\texorpdfstring{\texttt{riemann\_siegel\_theta}}{riemann\_siegel\_theta}}\label{riemann_siegel_theta}

\texttt{riemann\_siegel\_theta\ T} --- Riemann-Siegel θ(t) (asymptotic
Stirling form).

\section{\texorpdfstring{\texttt{dirichlet\_eta}}{dirichlet\_eta}}\label{dirichlet_eta}

\texttt{dirichlet\_eta\ S} --- Dirichlet η(s) = (1 − 2\^{}(1−s)) ζ(s).

\section{\texorpdfstring{\texttt{dirichlet\_beta}}{dirichlet\_beta}}\label{dirichlet_beta}

\texttt{dirichlet\_beta\ S} --- Dirichlet β(s) = Σ (-1)\^{}k /
(2k+1)\^{}s.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dirichlet\_beta(1)   \# π/4 (Catalan{-}like)}
\NormalTok{p dirichlet\_beta(2)   \# Catalan\textquotesingle{}s constant ≈ 0.9160}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-hypergeometric}
\chapter{Hypergeometric}\label{hypergeometric}

5 topics

\section{\texorpdfstring{\texttt{hypergeometric\_2f1}}{hypergeometric\_2f1}}\label{hypergeometric_2f1}

\texttt{hypergeometric\_2f1\ A,\ B,\ C,\ Z} --- ₂F₁(a, b; c; z) Gauss
hypergeometric. Series convergent for \textbar z\textbar{} \textless{}
1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p hypergeometric\_2f1(0.5, 0.5, 1, 0.5)  \# ≈ 1.1803}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hypergeometric\_1f1}}{hypergeometric\_1f1}}\label{hypergeometric_1f1}

\texttt{hypergeometric\_1f1\ A,\ B,\ Z} --- ₁F₁(a; b; z) Kummer /
confluent hypergeometric.

\section{\texorpdfstring{\texttt{hypergeometric\_0f1}}{hypergeometric\_0f1}}\label{hypergeometric_0f1}

\texttt{hypergeometric\_0f1\ B,\ Z} --- ₀F₁(; b; z). Related to Bessel:
J\_ν(x) = (x/2)\^{}ν / Γ(ν+1) · ₀F₁(; ν+1; -x²/4).

\section{\texorpdfstring{\texttt{hypergeometric\_pfq}}{hypergeometric\_pfq}}\label{hypergeometric_pfq}

\texttt{hypergeometric\_pfq\ AS,\ BS,\ Z} --- generalised \_pF\_q. AS,
BS are arrays of upper/lower parameters.

\section{\texorpdfstring{\texttt{hypergeometric\_u}}{hypergeometric\_u}}\label{hypergeometric_u}

\texttt{hypergeometric\_u\ A,\ B,\ Z} --- Tricomi\textquotesingle s
confluent U(a, b, z).

\protect\phantomsection\label{ch-modular-forms}
\chapter{Modular Forms}\label{modular-forms}

4 topics

\section{\texorpdfstring{\texttt{dedekind\_eta}}{dedekind\_eta}}\label{dedekind_eta}

\texttt{dedekind\_eta\ Y} --- Dedekind η(iy) on the imaginary axis.
Real-valued q-series with q = exp(-2π y).

\section{\texorpdfstring{\texttt{klein\_j}}{klein\_j}}\label{klein_j}

\texttt{klein\_j\ Y} --- Klein j-invariant j(iy) = E\_4³ / Δ.

\section{\texorpdfstring{\texttt{modular\_lambda}}{modular\_lambda}}\label{modular_lambda}

\texttt{modular\_lambda\ Y} --- Modular λ(iy) = θ\_2(0, q)\^{}4 /
θ\_3(0, q)\^{}4.

\section{\texorpdfstring{\texttt{ramanujan\_tau}}{ramanujan\_tau}}\label{ramanujan_tau}

\texttt{ramanujan\_tau\ N} --- τ(n), the nth coefficient of Δ(τ) =
η(τ)\^{}24. Returns an integer.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ramanujan\_tau(1)   \# 1}
\NormalTok{p ramanujan\_tau(2)   \# {-}24}
\NormalTok{p ramanujan\_tau(3)   \# 252}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-si-ci-ei-li-fresnel-integrals}
\chapter{Si / Ci / Ei / Li / Fresnel
Integrals}\label{si-ci-ei-li-fresnel-integrals}

9 topics

\section{\texorpdfstring{\texttt{sin\_integral}}{sin\_integral}}\label{sin_integral}

\texttt{sin\_integral\ X} --- Si(x) = ∫₀ˣ sin(t)/t dt. Si(∞) = π/2.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sin\_integral(1)    \# ≈ 0.9461}
\NormalTok{p sin\_integral(10)   \# ≈ 1.6583}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cos\_integral}}{cos\_integral}}\label{cos_integral}

\texttt{cos\_integral\ X} --- Ci(x) = γ + ln(x) + ∫₀ˣ (cos(t)−1)/t dt.
NaN for x ≤ 0.

\section{\texorpdfstring{\texttt{sinh\_integral}}{sinh\_integral}}\label{sinh_integral}

\texttt{sinh\_integral\ X} --- Shi(x) = ∫₀ˣ sinh(t)/t dt.

\section{\texorpdfstring{\texttt{cosh\_integral}}{cosh\_integral}}\label{cosh_integral}

\texttt{cosh\_integral\ X} --- Chi(x) = γ + ln(x) + ∫₀ˣ (cosh(t)−1)/t
dt.

\section{\texorpdfstring{\texttt{exp\_integral\_e}}{exp\_integral\_e}}\label{exp_integral_e}

\texttt{exp\_integral\_e\ N,\ X} --- generalised exponential integral
E\_n(x) = ∫\_1\^{}∞ e\^{}\{-x t\} / t\^{}n dt.

\section{\texorpdfstring{\texttt{exp\_integral\_ei}}{exp\_integral\_ei}}\label{exp_integral_ei}

\texttt{exp\_integral\_ei\ X} --- Ei(x). For x \textgreater{} 0 uses
series + asymptotic split.

\section{\texorpdfstring{\texttt{log\_integral}}{log\_integral}}\label{log_integral}

\texttt{log\_integral\ X} --- li(x) = Ei(ln x). Approximates the
prime-counting function near \texttt{prime\_pi}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p log\_integral(1000)   \# ≈ 178}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fresnel\_s}}{fresnel\_s}}\label{fresnel_s}

\texttt{fresnel\_s\ X} --- Fresnel S(x) = ∫₀ˣ sin(π t² / 2) dt.

\section{\texorpdfstring{\texttt{fresnel\_c}}{fresnel\_c}}\label{fresnel_c}

\texttt{fresnel\_c\ X} --- Fresnel C(x) = ∫₀ˣ cos(π t² / 2) dt.

\protect\phantomsection\label{ch-number-theory-wolfram-parity}
\chapter{Number Theory (Wolfram
Parity)}\label{number-theory-wolfram-parity}

13 topics

\section{\texorpdfstring{\texttt{jacobi\_symbol}}{jacobi\_symbol}}\label{jacobi_symbol}

\texttt{jacobi\_symbol\ A,\ N} --- Jacobi symbol (a/n) for positive odd
n. Returns -1, 0, or 1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p jacobi\_symbol(2, 7)  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kronecker\_symbol}}{kronecker\_symbol}}\label{kronecker_symbol}

\texttt{kronecker\_symbol\ A,\ N} --- Extension of the Jacobi symbol to
all integers n.

\section{\texorpdfstring{\texttt{primitive\_root}}{primitive\_root}}\label{primitive_root}

\texttt{primitive\_root\ P} --- Smallest primitive root mod p (p prime).
\texttt{undef} if none.

\section{\texorpdfstring{\texttt{multiplicative\_order}}{multiplicative\_order}}\label{multiplicative_order}

\texttt{multiplicative\_order\ A,\ N} --- smallest k \textgreater{} 0
with a\^{}k ≡ 1 (mod n). \texttt{undef} if gcd(a, n) ≠ 1.

\section{\texorpdfstring{\texttt{mangoldt\_lambda}}{mangoldt\_lambda}}\label{mangoldt_lambda}

\texttt{mangoldt\_lambda\ N} --- von Mangoldt Λ(n) = ln(p) if n =
p\^{}k, else 0.

\section{\texorpdfstring{\texttt{carmichael\_lambda}}{carmichael\_lambda}}\label{carmichael_lambda}

\texttt{carmichael\_lambda\ N} --- Carmichael λ(n), the exponent of
(Z/nZ)*.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p carmichael\_lambda(15)   \# 4}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squares\_r}}{squares\_r}}\label{squares_r}

\texttt{squares\_r\ K,\ N} --- number of representations of n as a sum
of k squares (signed, ordered).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p squares\_r(2, 5)   \# 8 (e.g. ±1²+±2²)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thue\_morse}}{thue\_morse}}\label{thue_morse}

\texttt{thue\_morse\ N} --- Thue-Morse t(n) = popcount(n) mod 2.

\section{\texorpdfstring{\texttt{rudin\_shapiro}}{rudin\_shapiro}}\label{rudin_shapiro}

\texttt{rudin\_shapiro\ N} --- Rudin-Shapiro sequence, ±1 = (-1)\^{}a(n)
where a(n) counts "11" patterns in binary(n).

\section{\texorpdfstring{\texttt{farey\_sequence}}{farey\_sequence}}\label{farey_sequence}

\texttt{farey\_sequence\ N} --- Farey sequence F\_n. Returns array of
\texttt{{[}a,\ b{]}} pairs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p farey\_sequence(3)   \# [[0,1],[1,3],[1,2],[2,3],[1,1]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frobenius\_number}}{frobenius\_number}}\label{frobenius_number}

\texttt{frobenius\_number\ COINS} --- largest amount NOT representable
as a non-negative combination of \texttt{COINS}. Closed form for two
coprime denominations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p frobenius\_number([3, 5])   \# 7}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frobenius\_solve}}{frobenius\_solve}}\label{frobenius_solve}

\texttt{frobenius\_solve\ COINS,\ N} --- number of ways to make change
for N using \texttt{COINS}.

\section{\texorpdfstring{\texttt{stern\_brocot}}{stern\_brocot}}\label{stern_brocot}

\texttt{stern\_brocot\ N} --- Stern-Brocot tree node N (1-indexed) as
\texttt{{[}a,\ b{]}} (Calkin-Wilf order).

\protect\phantomsection\label{ch-combinatorics-wolfram-parity}
\chapter{Combinatorics (Wolfram
Parity)}\label{combinatorics-wolfram-parity}

8 topics

\section{\texorpdfstring{\texttt{stirling\_s1}}{stirling\_s1}}\label{stirling_s1}

\texttt{stirling\_s1\ N,\ K} --- unsigned Stirling number of the first
kind \textbar s(n,k)\textbar.

\section{\texorpdfstring{\texttt{bell\_polynomial\_b}}{bell\_polynomial\_b}}\label{bell_polynomial_b}

\texttt{bell\_polynomial\_b\ N,\ K,\ XS} --- partial Bell polynomial
B\_\{n,k\}(x\_1, \ldots, x\_\{n-k+1\}).

\section{\texorpdfstring{\texttt{clebsch\_gordan}}{clebsch\_gordan}}\label{clebsch_gordan}

\texttt{clebsch\_gordan\ J1,\ J2,\ J,\ M1,\ M2\ {[},\ M{]}} ---
Clebsch-Gordan coefficient. M defaults to M1 + M2.

\section{\texorpdfstring{\texttt{three\_j\_symbol}}{three\_j\_symbol}}\label{three_j_symbol}

\texttt{three\_j\_symbol\ J1,\ J2,\ J3,\ M1,\ M2,\ M3} --- Wigner 3-j
symbol.

\section{\texorpdfstring{\texttt{six\_j\_symbol}}{six\_j\_symbol}}\label{six_j_symbol}

\texttt{six\_j\_symbol\ J1\ J2\ J3\ J4\ J5\ J6} --- Wigner 6-j symbol.

\section{\texorpdfstring{\texttt{nine\_j\_symbol}}{nine\_j\_symbol}}\label{nine_j_symbol}

\texttt{nine\_j\_symbol} (9 args) --- Wigner 9-j as a single sum over
6-j.

\section{\texorpdfstring{\texttt{debruijn\_sequence}}{debruijn\_sequence}}\label{debruijn_sequence}

\texttt{debruijn\_sequence\ K,\ N} --- De Bruijn B(k, n) as an array of
k\^{}n integers.

\section{\texorpdfstring{\texttt{wigner\_d}}{wigner\_d}}\label{wigner_d}

\texttt{wigner\_d\ J,\ M1,\ M2,\ BETA} --- small Wigner d-matrix
d\^{}j\_\{m1, m2\}(β).

\protect\phantomsection\label{ch-q-series-mittag-leffler-coulomb}
\chapter{q-Series, Mittag-Leffler,
Coulomb}\label{q-series-mittag-leffler-coulomb}

7 topics

\section{\texorpdfstring{\texttt{q\_pochhammer}}{q\_pochhammer}}\label{q_pochhammer}

\texttt{q\_pochhammer\ A,\ Q\ {[},\ N{]}} --- (a; q)\_n. Omit N for the
infinite product (\textbar q\textbar{} \textless{} 1).

\section{\texorpdfstring{\texttt{q\_factorial}}{q\_factorial}}\label{q_factorial}

\texttt{q\_factorial\ N,\ Q} --- q-factorial {[}n{]}\_q!.

\section{\texorpdfstring{\texttt{q\_binomial}}{q\_binomial}}\label{q_binomial}

\texttt{q\_binomial\ N,\ K,\ Q} --- Gaussian binomial {[}n choose
k{]}\_q.

\section{\texorpdfstring{\texttt{q\_hypergeometric\_pfq}}{q\_hypergeometric\_pfq}}\label{q_hypergeometric_pfq}

\texttt{q\_hypergeometric\_pfq\ AS,\ BS,\ Q,\ Z} ---
basic-hypergeometric series.

\section{\texorpdfstring{\texttt{mittag\_leffler\_e}}{mittag\_leffler\_e}}\label{mittag_leffler_e}

\texttt{mittag\_leffler\_e\ ALPHA,\ BETA,\ Z} --- E\_\{α,β\}(z) = Σ
z\^{}k / Γ(α k + β). Generalises exp / cosh / Mittag-Leffler.

\section{\texorpdfstring{\texttt{coulomb\_wave\_f}}{coulomb\_wave\_f}}\label{coulomb_wave_f}

\texttt{coulomb\_wave\_f\ L,\ ETA,\ RHO} --- regular Coulomb wave
F\_L(η, ρ) via the confluent-hypergeometric representation.

\section{\texorpdfstring{\texttt{coulomb\_wave\_g}}{coulomb\_wave\_g}}\label{coulomb_wave_g}

\texttt{coulomb\_wave\_g\ L,\ ETA,\ RHO} --- irregular partner G\_L.
Currently returns NaN; faithful Bardin/Goesnig port pending.

\protect\phantomsection\label{ch-inverse-special-functions}
\chapter{Inverse Special Functions}\label{inverse-special-functions}

4 topics

\section{\texorpdfstring{\texttt{inverse\_erf}}{inverse\_erf}}\label{inverse_erf}

\texttt{inverse\_erf\ Y} --- inverse error function. Solves erf(x) = y.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p inverse\_erf(0.5)   \# ≈ 0.4769}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_erfc}}{inverse\_erfc}}\label{inverse_erfc}

\texttt{inverse\_erfc\ Y} --- inverse complementary error function.

\section{\texorpdfstring{\texttt{inverse\_gamma\_regularized}}{inverse\_gamma\_regularized}}\label{inverse_gamma_regularized}

\texttt{inverse\_gamma\_regularized\ A,\ Y} --- solves P(a, x) = y for
x.

\section{\texorpdfstring{\texttt{inverse\_beta\_regularized}}{inverse\_beta\_regularized}}\label{inverse_beta_regularized}

\texttt{inverse\_beta\_regularized\ A,\ B,\ Y} --- solves I\_x(a, b) = y
for x via bisection.

\protect\phantomsection\label{ch-piecewise-symbolic-primitives}
\chapter{Piecewise \& Symbolic
Primitives}\label{piecewise-symbolic-primitives}

8 topics

\section{\texorpdfstring{\texttt{dirac\_delta}}{dirac\_delta}}\label{dirac_delta}

\texttt{dirac\_delta\ X\ {[},\ EPS{]}} --- finite-width discrete
approximation: 1/eps if \textbar x\textbar{} \textless{} eps/2 else 0.
EPS defaults to 1e-3.

\section{\texorpdfstring{\texttt{heaviside\_theta}}{heaviside\_theta}}\label{heaviside_theta}

\texttt{heaviside\_theta\ X} --- Heaviside step function: 1 (x
\textgreater{} 0), 0 (x \textless{} 0), 0.5 (x = 0).

\section{\texorpdfstring{\texttt{unit\_box}}{unit\_box}}\label{unit_box}

\texttt{unit\_box\ X} --- 1 if \textbar x\textbar{} ≤ 1/2 else 0.

\section{\texorpdfstring{\texttt{unit\_triangle}}{unit\_triangle}}\label{unit_triangle}

\texttt{unit\_triangle\ X} --- max(1 − \textbar x\textbar, 0).

\section{\texorpdfstring{\texttt{square\_wave}}{square\_wave}}\label{square_wave}

\texttt{square\_wave\ X\ {[},\ PERIOD{]}} --- alternates +1/-1 with the
given period (default 1).

\section{\texorpdfstring{\texttt{triangle\_wave}}{triangle\_wave}}\label{triangle_wave}

\texttt{triangle\_wave\ X\ {[},\ PERIOD{]}} --- periodic triangle wave
on {[}-1, 1{]}.

\section{\texorpdfstring{\texttt{sawtooth\_wave}}{sawtooth\_wave}}\label{sawtooth_wave}

\texttt{sawtooth\_wave\ X\ {[},\ PERIOD{]}} --- periodic sawtooth on
{[}-1, 1{]}.

\section{\texorpdfstring{\texttt{dirac\_comb}}{dirac\_comb}}\label{dirac_comb}

\texttt{dirac\_comb\ X,\ T\ {[},\ EPS{]}} --- sum of Dirac deltas at
multiples of T (discrete approximation).

\protect\phantomsection\label{ch-number-theory-wolfram-parity-ii}
\chapter{Number Theory (Wolfram Parity
II)}\label{number-theory-wolfram-parity-ii}

14 topics

\section{\texorpdfstring{\texttt{liouville\_lambda}}{liouville\_lambda}}\label{liouville_lambda}

\texttt{liouville\_lambda\ N} --- Liouville λ(n) = (-1)\^{}Ω(n).

\section{\texorpdfstring{\texttt{jordan\_totient}}{jordan\_totient}}\label{jordan_totient}

\texttt{jordan\_totient\ K,\ N} --- Jordan totient J\_k(n) = n\^{}k
Π\_\{p \textbar{} n\} (1 - p\^{}\{-k\}).

\section{\texorpdfstring{\texttt{ramanujan\_sum}}{ramanujan\_sum}}\label{ramanujan_sum}

\texttt{ramanujan\_sum\ Q,\ N} --- c\_q(n) = Σ\_\{d \textbar{}
gcd(q,n)\} μ(q/d) d.

\section{\texorpdfstring{\texttt{cyclotomic\_polynomial}}{cyclotomic\_polynomial}}\label{cyclotomic_polynomial}

\texttt{cyclotomic\_polynomial\ N} --- coefficient list of Φ\_n(x).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyclotomic\_polynomial(6)   \# [1, {-}1, 1] = x²{-}x+1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{legendre\_symbol}}{legendre\_symbol}}\label{legendre_symbol}

\texttt{legendre\_symbol\ A,\ P} --- Legendre symbol (a/p) for prime p.
-1, 0, or 1.

\section{\texorpdfstring{\texttt{pythagorean\_triple\_q}}{pythagorean\_triple\_q}}\label{pythagorean_triple_q}

\texttt{pythagorean\_triple\_q\ A,\ B,\ C} --- 1 if a² + b² = c² (any
order/sign).

\section{\texorpdfstring{\texttt{gen\_pythagorean\_triple}}{gen\_pythagorean\_triple}}\label{gen_pythagorean_triple}

\texttt{gen\_pythagorean\_triple\ M,\ N} --- Euclid formula: returns
{[}m²-n², 2mn, m²+n²{]}.

\section{\texorpdfstring{\texttt{sophie\_germain\_q}}{sophie\_germain\_q}}\label{sophie_germain_q}

\texttt{sophie\_germain\_q\ P} --- 1 if both p and 2p+1 are prime.

\section{\texorpdfstring{\texttt{mersenne\_q}}{mersenne\_q}}\label{mersenne_q}

\texttt{mersenne\_q\ N} --- 1 if 2\^{}n - 1 is a Mersenne prime
(Lucas-Lehmer).

\section{\texorpdfstring{\texttt{lucas\_lehmer\_test}}{lucas\_lehmer\_test}}\label{lucas_lehmer_test}

\texttt{lucas\_lehmer\_test\ P} --- Lucas-Lehmer primality test for
2\^{}p - 1.

\section{\texorpdfstring{\texttt{continued\_fraction}}{continued\_fraction}}\label{continued_fraction}

\texttt{continued\_fraction\ X\ {[},\ N{]}} --- first N coefficients of
the simple continued-fraction expansion. N defaults to 12.

\section{\texorpdfstring{\texttt{from\_continued\_fraction}}{from\_continued\_fraction}}\label{from_continued_fraction}

\texttt{from\_continued\_fraction\ COEFFS} --- evaluate {[}a0; a1, a2,
\ldots{]} back to a real number.

\section{\texorpdfstring{\texttt{convergents}}{convergents}}\label{convergents}

\texttt{convergents\ X\ {[},\ N{]}} --- N successive {[}num, denom{]}
convergents.

\section{\texorpdfstring{\texttt{best\_rational\_approximation}}{best\_rational\_approximation}}\label{best_rational_approximation}

\texttt{best\_rational\_approximation\ X,\ MAX\_DENOM} --- closest
fraction p/q with q ≤ MAX\_DENOM. Returns {[}p, q{]}.

\protect\phantomsection\label{ch-combinatorial-sequences}
\chapter{Combinatorial Sequences}\label{combinatorial-sequences}

12 topics

\section{\texorpdfstring{\texttt{motzkin\_number}}{motzkin\_number}}\label{motzkin_number}

\texttt{motzkin\_number\ N} --- \# paths on (0..n) using → ↗ ↘ steps (no
crossings).

\section{\texorpdfstring{\texttt{narayana\_number}}{narayana\_number}}\label{narayana_number}

\texttt{narayana\_number\ N,\ K} --- N(n, k) = (1/n) C(n,k) C(n,k-1).

\section{\texorpdfstring{\texttt{delannoy\_number}}{delannoy\_number}}\label{delannoy_number}

\texttt{delannoy\_number\ M,\ N} --- \# paths in (m+1)×(n+1) grid using
→ ↑ ↗.

\section{\texorpdfstring{\texttt{schroder\_number}}{schroder\_number}}\label{schroder_number}

\texttt{schroder\_number\ N} --- large Schröder number.

\section{\texorpdfstring{\texttt{small\_schroder\_number}}{small\_schroder\_number}}\label{small_schroder_number}

\texttt{small\_schroder\_number\ N} --- small Schröder s\_n = S\_n / 2
(n ≥ 1).

\section{\texorpdfstring{\texttt{eulerian\_number}}{eulerian\_number}}\label{eulerian_number}

\texttt{eulerian\_number\ N,\ K} --- ⟨n k⟩, \# permutations of {[}n{]}
with k ascents.

\section{\texorpdfstring{\texttt{bernoulli\_polynomial}}{bernoulli\_polynomial}}\label{bernoulli_polynomial}

\texttt{bernoulli\_polynomial\ N,\ X} --- B\_n(x).

\section{\texorpdfstring{\texttt{euler\_polynomial}}{euler\_polynomial}}\label{euler_polynomial}

\texttt{euler\_polynomial\ N,\ X} --- E\_n(x).

\section{\texorpdfstring{\texttt{pell\_number}}{pell\_number}}\label{pell_number}

\texttt{pell\_number\ N} --- Pell number P\_n.

\section{\texorpdfstring{\texttt{pell\_lucas\_number}}{pell\_lucas\_number}}\label{pell_lucas_number}

\texttt{pell\_lucas\_number\ N} --- companion Pell-Lucas Q\_n.

\section{\texorpdfstring{\texttt{perrin\_number}}{perrin\_number}}\label{perrin_number}

\texttt{perrin\_number\ N} --- Perrin sequence P(n) = P(n-2) + P(n-3).

\section{\texorpdfstring{\texttt{padovan\_number}}{padovan\_number}}\label{padovan_number}

\texttt{padovan\_number\ N} --- Padovan sequence (same recurrence,
different seeds).

\protect\phantomsection\label{ch-linear-algebra-extended}
\chapter{Linear Algebra (Extended)}\label{linear-algebra-extended}

8 topics

\section{\texorpdfstring{\texttt{kronecker\_product}}{kronecker\_product}}\label{kronecker_product}

\texttt{kronecker\_product\ A,\ B} --- A ⊗ B (block-by-block outer
product).

\section{\texorpdfstring{\texttt{tensor\_product}}{tensor\_product}}\label{tensor_product}

\texttt{tensor\_product\ A,\ B} --- outer product of two flat vectors →
matrix A\_i B\_j.

\section{\texorpdfstring{\texttt{tensor\_contract}}{tensor\_contract}}\label{tensor_contract}

\texttt{tensor\_contract\ A,\ B} --- Frobenius inner product of two
matrices.

\section{\texorpdfstring{\texttt{matrix\_rank}}{matrix\_rank}}\label{matrix_rank}

\texttt{matrix\_rank\ A} --- rank via Gaussian elimination with partial
pivoting.

\section{\texorpdfstring{\texttt{companion\_matrix}}{companion\_matrix}}\label{companion_matrix}

\texttt{companion\_matrix\ {[}a0,\ a1,\ …,\ a\_\{n-1\}{]}} --- companion
of x\^{}n + a\_\{n-1\} x\^{}\{n-1\} + \ldots{} + a\_0.

\section{\texorpdfstring{\texttt{characteristic\_polynomial}}{characteristic\_polynomial}}\label{characteristic_polynomial}

\texttt{characteristic\_polynomial\ A} --- coefficients {[}a\_0, \ldots,
a\_n{]} of det(xI − A) via Faddeev-LeVerrier.

\section{\texorpdfstring{\texttt{singular\_values}}{singular\_values}}\label{singular_values}

\texttt{singular\_values\ A} --- sorted SVDs of A (eigenvalues of A\^{}T
A, square-rooted).

\section{\texorpdfstring{\texttt{nullspace}}{nullspace}}\label{nullspace}

\texttt{nullspace\ A} --- basis vectors of A\textquotesingle s null
space (zero singular values of A\^{}T A).

\protect\phantomsection\label{ch-polynomial-algebra}
\chapter{Polynomial Algebra}\label{polynomial-algebra}

6 topics

\section{\texorpdfstring{\texttt{polynomial\_gcd}}{polynomial\_gcd}}\label{polynomial_gcd}

\texttt{polynomial\_gcd\ P,\ Q} --- Euclidean GCD over real coefficients
(monic).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p polygcd([{-}1, 0, 1], [{-}1, 1])   \# x {-} 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polynomial\_quotient}}{polynomial\_quotient}}\label{polynomial_quotient}

\texttt{polynomial\_quotient\ P,\ Q} --- quotient of synthetic division.

\section{\texorpdfstring{\texttt{polynomial\_remainder}}{polynomial\_remainder}}\label{polynomial_remainder}

\texttt{polynomial\_remainder\ P,\ Q} --- remainder of synthetic
division.

\section{\texorpdfstring{\texttt{polynomial\_resultant}}{polynomial\_resultant}}\label{polynomial_resultant}

\texttt{polynomial\_resultant\ P,\ Q} --- Sylvester-matrix determinant.

\section{\texorpdfstring{\texttt{polynomial\_discriminant}}{polynomial\_discriminant}}\label{polynomial_discriminant}

\texttt{polynomial\_discriminant\ P} --- disc(p) = (-1)\^{}\{n(n-1)/2\}
/ a\_n · res(p, p\textquotesingle).

\section{\texorpdfstring{\texttt{polynomial\_roots}}{polynomial\_roots}}\label{polynomial_roots}

\texttt{polynomial\_roots\ P} --- real roots via deflation power
iteration on companion matrix.

\protect\phantomsection\label{ch-distributions-extended}
\chapter{Distributions (Extended)}\label{distributions-extended}

18 topics

\section{\texorpdfstring{\texttt{gumbel\_pdf}}{gumbel\_pdf}}\label{gumbel_pdf}

\texttt{gumbel\_pdf\ X,\ MU,\ BETA} --- Gumbel (Type I) extreme-value
PDF.

\section{\texorpdfstring{\texttt{gumbel\_cdf}}{gumbel\_cdf}}\label{gumbel_cdf}

\texttt{gumbel\_cdf\ X,\ MU,\ BETA} --- Gumbel CDF.

\section{\texorpdfstring{\texttt{gumbel\_quantile}}{gumbel\_quantile}}\label{gumbel_quantile}

\texttt{gumbel\_quantile\ P,\ MU,\ BETA} --- Gumbel quantile.

\section{\texorpdfstring{\texttt{frechet\_pdf}}{frechet\_pdf}}\label{frechet_pdf}

\texttt{frechet\_pdf\ X,\ ALPHA,\ S} --- Fréchet (Type II) PDF.

\section{\texorpdfstring{\texttt{frechet\_cdf}}{frechet\_cdf}}\label{frechet_cdf}

\texttt{frechet\_cdf\ X,\ ALPHA,\ S} --- Fréchet CDF.

\section{\texorpdfstring{\texttt{frechet\_quantile}}{frechet\_quantile}}\label{frechet_quantile}

\texttt{frechet\_quantile\ P,\ ALPHA,\ S} --- Fréchet quantile.

\section{\texorpdfstring{\texttt{logistic\_pdf}}{logistic\_pdf}}\label{logistic_pdf}

\texttt{logistic\_pdf\ X,\ MU,\ S} --- Logistic PDF.

\section{\texorpdfstring{\texttt{logistic\_cdf}}{logistic\_cdf}}\label{logistic_cdf}

\texttt{logistic\_cdf\ X,\ MU,\ S} --- Logistic CDF.

\section{\texorpdfstring{\texttt{logistic\_quantile}}{logistic\_quantile}}\label{logistic_quantile}

\texttt{logistic\_quantile\ P,\ MU,\ S} --- Logistic quantile.

\section{\texorpdfstring{\texttt{rayleigh\_pdf}}{rayleigh\_pdf}}\label{rayleigh_pdf}

\texttt{rayleigh\_pdf\ X,\ SIGMA} --- Rayleigh PDF (x ≥ 0).

\section{\texorpdfstring{\texttt{rayleigh\_cdf}}{rayleigh\_cdf}}\label{rayleigh_cdf}

\texttt{rayleigh\_cdf\ X,\ SIGMA} --- Rayleigh CDF.

\section{\texorpdfstring{\texttt{rayleigh\_quantile}}{rayleigh\_quantile}}\label{rayleigh_quantile}

\texttt{rayleigh\_quantile\ P,\ SIGMA} --- Rayleigh quantile.

\section{\texorpdfstring{\texttt{inverse\_gamma\_pdf}}{inverse\_gamma\_pdf}}\label{inverse_gamma_pdf}

\texttt{inverse\_gamma\_pdf\ X,\ ALPHA,\ BETA} --- inverse-gamma PDF.

\section{\texorpdfstring{\texttt{inverse\_gamma\_cdf}}{inverse\_gamma\_cdf}}\label{inverse_gamma_cdf}

\texttt{inverse\_gamma\_cdf\ X,\ ALPHA,\ BETA} --- inverse-gamma CDF.

\section{\texorpdfstring{\texttt{inverse\_gamma\_quantile}}{inverse\_gamma\_quantile}}\label{inverse_gamma_quantile}

\texttt{inverse\_gamma\_quantile\ P,\ ALPHA,\ BETA} --- inverse-gamma
quantile.

\section{\texorpdfstring{\texttt{kumaraswamy\_pdf}}{kumaraswamy\_pdf}}\label{kumaraswamy_pdf}

\texttt{kumaraswamy\_pdf\ X,\ A,\ B} --- Kumaraswamy PDF on (0, 1).

\section{\texorpdfstring{\texttt{kumaraswamy\_cdf}}{kumaraswamy\_cdf}}\label{kumaraswamy_cdf}

\texttt{kumaraswamy\_cdf\ X,\ A,\ B} --- Kumaraswamy CDF.

\section{\texorpdfstring{\texttt{kumaraswamy\_quantile}}{kumaraswamy\_quantile}}\label{kumaraswamy_quantile}

\texttt{kumaraswamy\_quantile\ P,\ A,\ B} --- Kumaraswamy quantile.

\protect\phantomsection\label{ch-mathieu-heun}
\chapter{Mathieu / Heun}\label{mathieu-heun}

4 topics

\section{\texorpdfstring{\texttt{mathieu\_a}}{mathieu\_a}}\label{mathieu_a}

\texttt{mathieu\_a\ Q,\ N} --- Mathieu characteristic value a\_n(q)
(Hill-matrix eigenvalue).

\section{\texorpdfstring{\texttt{mathieu\_ce}}{mathieu\_ce}}\label{mathieu_ce}

\texttt{mathieu\_ce\ N,\ X,\ Q} --- even Mathieu function ce\_n(x, q)
(perturbative form for small q).

\section{\texorpdfstring{\texttt{mathieu\_se}}{mathieu\_se}}\label{mathieu_se}

\texttt{mathieu\_se\ N,\ X,\ Q} --- odd Mathieu function se\_n(x, q).

\section{\texorpdfstring{\texttt{heun\_g}}{heun\_g}}\label{heun_g}

\texttt{heun\_g\ Z,\ A,\ Q,\ ALPHA,\ BETA,\ GAMMA,\ DELTA} --- general
Heun H\_l via Frobenius series. Requires \textbar z\textbar{}
\textless{} min(1, \textbar a\textbar).

\protect\phantomsection\label{ch-wavelets}
\chapter{Wavelets}\label{wavelets}

4 topics

\section{\texorpdfstring{\texttt{haar\_transform}}{haar\_transform}}\label{haar_transform}

\texttt{haar\_transform\ XS} --- single-level Haar DWT. Returns
{[}approx\ldots, detail\ldots{]}.

\section{\texorpdfstring{\texttt{haar\_inverse}}{haar\_inverse}}\label{haar_inverse}

\texttt{haar\_inverse\ XS} --- inverse single-level Haar.

\section{\texorpdfstring{\texttt{daubechies\_db4}}{daubechies\_db4}}\label{daubechies_db4}

\texttt{daubechies\_db4\ XS} --- single-level Daubechies-4 DWT (length
must be even ≥ 4).

\section{\texorpdfstring{\texttt{daubechies\_db4\_inverse}}{daubechies\_db4\_inverse}}\label{daubechies_db4_inverse}

\texttt{daubechies\_db4\_inverse\ XS} --- inverse single-level db4.

\protect\phantomsection\label{ch-graph-algorithms-extended}
\chapter{Graph Algorithms (Extended)}\label{graph-algorithms-extended}

8 topics

\section{\texorpdfstring{\texttt{topo\_sort\_adj}}{topo\_sort\_adj}}\label{topo_sort_adj}

\texttt{topo\_sort\_adj\ ADJ} --- Kahn\textquotesingle s algorithm on
adjacency-list graph. Returns ordering or \texttt{{[}{]}} on cycle.
(Edge-list input → use \texttt{topological\_sort} instead.)

\section{\texorpdfstring{\texttt{scc\_tarjan}}{scc\_tarjan}}\label{scc_tarjan}

\texttt{scc\_tarjan\ ADJ} --- Tarjan strongly-connected components.
Returns array of components.

\section{\texorpdfstring{\texttt{bipartite\_q}}{bipartite\_q}}\label{bipartite_q}

\texttt{bipartite\_q\ ADJ} --- 1 if graph is 2-colourable (BFS), 0
otherwise.

\section{\texorpdfstring{\texttt{max\_flow\_edmonds\_karp}}{max\_flow\_edmonds\_karp}}\label{max_flow_edmonds_karp}

\texttt{max\_flow\_edmonds\_karp\ CAP,\ S,\ T} --- max flow on capacity
matrix from S to T.

\section{\texorpdfstring{\texttt{min\_cut}}{min\_cut}}\label{min_cut}

\texttt{min\_cut\ CAP,\ S,\ T} --- min-cut value (= max-flow).

\section{\texorpdfstring{\texttt{eccentricity}}{eccentricity}}\label{eccentricity}

\texttt{eccentricity\ ADJ,\ V} --- max BFS distance from V (unweighted).

\section{\texorpdfstring{\texttt{graph\_diameter}}{graph\_diameter}}\label{graph_diameter}

\texttt{graph\_diameter\ ADJ} --- max eccentricity over all vertices.

\section{\texorpdfstring{\texttt{graph\_radius}}{graph\_radius}}\label{graph_radius}

\texttt{graph\_radius\ ADJ} --- min eccentricity over all vertices.

\protect\phantomsection\label{ch-number-theoretic-sums-constants}
\chapter{Number-Theoretic Sums \&
Constants}\label{number-theoretic-sums-constants}

5 topics

\section{\texorpdfstring{\texttt{stieltjes\_constant}}{stieltjes\_constant}}\label{stieltjes_constant}

\texttt{stieltjes\_constant\ K} --- kth Stieltjes constant γ\_k. γ\_0 =
γ (Euler-Mascheroni).

\section{\texorpdfstring{\texttt{gauss\_sum}}{gauss\_sum}}\label{gauss_sum}

\texttt{gauss\_sum\ A,\ P} --- quadratic Gauss sum G(a, p) as
\texttt{{[}Re,\ Im{]}}.

\section{\texorpdfstring{\texttt{kloosterman\_sum}}{kloosterman\_sum}}\label{kloosterman_sum}

\texttt{kloosterman\_sum\ A,\ B,\ M} --- K(a, b; m) as
\texttt{{[}Re,\ Im{]}}.

\section{\texorpdfstring{\texttt{eta\_quotient}}{eta\_quotient}}\label{eta_quotient}

\texttt{eta\_quotient\ PAIRS,\ Y} --- Π η(d·iy)\^{}\{r\_d\} for {[}{[}d,
r\_d{]}, \ldots{]}.

\section{\texorpdfstring{\texttt{root\_approximant}}{root\_approximant}}\label{root_approximant}

\texttt{root\_approximant\ X\ {[},\ MAX\_DENOM{]}} --- best rational
approximant (alias for \texttt{best\_rational\_approximation}).

\protect\phantomsection\label{ch-vector-calculus}
\chapter{Vector Calculus}\label{vector-calculus}

6 topics

\section{\texorpdfstring{\texttt{numerical\_gradient}}{numerical\_gradient}}\label{numerical_gradient}

\texttt{numerical\_gradient\ F,\ POINT\ {[},\ H{]}} ---
central-difference ∇f. F receives a single arrayref
\texttt{\$\_{[}0{]}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn quad \{ my @y = @\{$\_[0]\}; $y[0]**2 + 2*$y[1]**2 \}}
\NormalTok{my @g = ngrad(\textbackslash{}\&quad, [3, 4])    \# (6, 16)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{numerical\_jacobian}}{numerical\_jacobian}}\label{numerical_jacobian}

\texttt{numerical\_jacobian\ F,\ POINT\ {[},\ H{]}} --- Jacobian of
vector-valued F.

\section{\texorpdfstring{\texttt{numerical\_hessian}}{numerical\_hessian}}\label{numerical_hessian}

\texttt{numerical\_hessian\ F,\ POINT\ {[},\ H{]}} --- symmetric Hessian
via mixed second differences.

\section{\texorpdfstring{\texttt{numerical\_divergence}}{numerical\_divergence}}\label{numerical_divergence}

\texttt{numerical\_divergence\ F,\ POINT\ {[},\ H{]}} --- div of vector
field F.

\section{\texorpdfstring{\texttt{numerical\_curl}}{numerical\_curl}}\label{numerical_curl}

\texttt{numerical\_curl\ F,\ POINT\ {[},\ H{]}} --- 3-D curl returned as
\texttt{{[}c\_x,\ c\_y,\ c\_z{]}}.

\section{\texorpdfstring{\texttt{numerical\_laplacian}}{numerical\_laplacian}}\label{numerical_laplacian}

\texttt{numerical\_laplacian\ F,\ POINT\ {[},\ H{]}} --- ∇²f.

\protect\phantomsection\label{ch-optimization}
\chapter{Optimization}\label{optimization}

6 topics

\section{\texorpdfstring{\texttt{nelder\_mead}}{nelder\_mead}}\label{nelder_mead}

\texttt{nelder\_mead\ F,\ X0\ {[},\ MAX\_ITER,\ TOL{]}} --- Nelder-Mead
simplex minimisation. Returns \texttt{{[}x*,\ f(x*){]}}.

\section{\texorpdfstring{\texttt{gradient\_descent}}{gradient\_descent}}\label{gradient_descent}

\texttt{gradient\_descent\ F,\ GRAD,\ X0\ {[},\ STEP,\ ITERS{]}} ---
fixed-step descent.

\section{\texorpdfstring{\texttt{bfgs\_minimize}}{bfgs\_minimize}}\label{bfgs_minimize}

\texttt{bfgs\_minimize\ F,\ GRAD,\ X0\ {[},\ MAX\_ITER,\ TOL{]}} ---
BFGS quasi-Newton with Armijo line search.

\section{\texorpdfstring{\texttt{levenberg\_marquardt}}{levenberg\_marquardt}}\label{levenberg_marquardt}

\texttt{levenberg\_marquardt\ F\_RESID,\ X0\ {[},\ MAX\_ITER,\ TOL{]}}
--- nonlinear LSQ. F returns the residual vector.

\section{\texorpdfstring{\texttt{conjugate\_gradient}}{conjugate\_gradient}}\label{conjugate_gradient}

\texttt{conjugate\_gradient\ A,\ B} --- CG for symmetric positive
definite A x = b.

\section{\texorpdfstring{\texttt{least\_squares}}{least\_squares}}\label{least_squares}

\texttt{least\_squares\ A,\ B} --- solves A\^{}T A x = A\^{}T b.

\protect\phantomsection\label{ch-numerical-integration}
\chapter{Numerical Integration}\label{numerical-integration}

4 topics

\section{\texorpdfstring{\texttt{romberg}}{romberg}}\label{romberg}

\texttt{romberg\ F,\ A,\ B\ {[},\ LEVELS{]}} --- Romberg integration.
Doubles trapezoid then Richardson-extrapolates.

\section{\texorpdfstring{\texttt{gauss\_legendre\_quad}}{gauss\_legendre\_quad}}\label{gauss_legendre_quad}

\texttt{gauss\_legendre\_quad\ F,\ A,\ B\ {[},\ N{]}} --- N-point
Gauss-Legendre quadrature on {[}a, b{]} (default N=10).

\section{\texorpdfstring{\texttt{monte\_carlo\_integrate}}{monte\_carlo\_integrate}}\label{monte_carlo_integrate}

\texttt{monte\_carlo\_integrate\ F,\ A,\ B\ {[},\ N{]}} --- uniform
Monte Carlo over {[}a, b{]} with N samples (default 10 000).

\section{\texorpdfstring{\texttt{adaptive\_simpson}}{adaptive\_simpson}}\label{adaptive_simpson}

\texttt{adaptive\_simpson\ F,\ A,\ B\ {[},\ TOL,\ MAX\_DEPTH{]}} ---
adaptive Simpson with Richardson tail.

\protect\phantomsection\label{ch-linear-algebra-numeric}
\chapter{Linear Algebra (Numeric)}\label{linear-algebra-numeric}

7 topics

\section{\texorpdfstring{\texttt{lu\_decompose}}{lu\_decompose}}\label{lu_decompose}

\texttt{lu\_decompose\ A} → \texttt{{[}L,\ U,\ P{]}} with P A = L U; P
stored as a row-permutation vector.

\section{\texorpdfstring{\texttt{qr\_decompose}}{qr\_decompose}}\label{qr_decompose}

\texttt{qr\_decompose\ A} → \texttt{{[}Q,\ R{]}} via Gram-Schmidt.

\section{\texorpdfstring{\texttt{householder\_reflector}}{householder\_reflector}}\label{householder_reflector}

\texttt{householder\_reflector\ V} → I − 2 v v\^{}T / (v · v).

\section{\texorpdfstring{\texttt{givens\_rotation}}{givens\_rotation}}\label{givens_rotation}

\texttt{givens\_rotation\ A,\ B} → \texttt{{[}c,\ s{]}} such that the
rotation {[}c -s; s c{]} zeros the second component.

\section{\texorpdfstring{\texttt{forward\_substitute}}{forward\_substitute}}\label{forward_substitute}

\texttt{forward\_substitute\ L,\ B} --- solve L x = b for
lower-triangular L.

\section{\texorpdfstring{\texttt{back\_substitute}}{back\_substitute}}\label{back_substitute}

\texttt{back\_substitute\ U,\ B} --- solve U x = b for upper-triangular
U.

\section{\texorpdfstring{\texttt{hessenberg\_reduce}}{hessenberg\_reduce}}\label{hessenberg_reduce}

\texttt{hessenberg\_reduce\ A} --- orthogonal Hessenberg form via
Householder reflections.

\protect\phantomsection\label{ch-polynomial-helpers}
\chapter{Polynomial Helpers}\label{polynomial-helpers}

5 topics

\section{\texorpdfstring{\texttt{poly\_derivative}}{poly\_derivative}}\label{poly_derivative}

\texttt{poly\_derivative\ P} --- coefficient-list derivative of
polynomial P (low-to-high order).

\section{\texorpdfstring{\texttt{poly\_integrate}}{poly\_integrate}}\label{poly_integrate}

\texttt{poly\_integrate\ P\ {[},\ C{]}} --- antiderivative with constant
C (default 0).

\section{\texorpdfstring{\texttt{poly\_compose}}{poly\_compose}}\label{poly_compose}

\texttt{poly\_compose\ P,\ Q} → coefficients of P(Q(x)).

\section{\texorpdfstring{\texttt{poly\_eval\_horner}}{poly\_eval\_horner}}\label{poly_eval_horner}

\texttt{poly\_eval\_horner\ P,\ X} --- Horner-rule polynomial
evaluation.

\section{\texorpdfstring{\texttt{pade\_approximant}}{pade\_approximant}}\label{pade_approximant}

\texttt{pade\_approximant\ TAYLOR,\ M,\ N} → \texttt{{[}num,\ den{]}}
Padé approximation.

\protect\phantomsection\label{ch-quaternions-3d-rotations}
\chapter{Quaternions \& 3D Rotations}\label{quaternions-3d-rotations}

12 topics

\section{\texorpdfstring{\texttt{quat\_mul}}{quat\_mul}}\label{quat_mul}

\texttt{quat\_mul\ A,\ B} --- Hamilton product (w, x, y, z).

\section{\texorpdfstring{\texttt{quat\_conj}}{quat\_conj}}\label{quat_conj}

\texttt{quat\_conj\ Q} --- conjugate (w, -x, -y, -z).

\section{\texorpdfstring{\texttt{quat\_norm}}{quat\_norm}}\label{quat_norm}

\texttt{quat\_norm\ Q} --- Euclidean norm.

\section{\texorpdfstring{\texttt{quat\_inv}}{quat\_inv}}\label{quat_inv}

\texttt{quat\_inv\ Q} --- inverse Q* / \textbar Q\textbar².

\section{\texorpdfstring{\texttt{quat\_from\_axis\_angle}}{quat\_from\_axis\_angle}}\label{quat_from_axis_angle}

\texttt{quat\_from\_axis\_angle\ AXIS,\ THETA} --- unit quaternion
encoding rotation about AXIS by THETA radians.

\section{\texorpdfstring{\texttt{quat\_to\_axis\_angle}}{quat\_to\_axis\_angle}}\label{quat_to_axis_angle}

\texttt{quat\_to\_axis\_angle\ Q} → \texttt{{[}axis,\ theta{]}}.

\section{\texorpdfstring{\texttt{quat\_to\_matrix}}{quat\_to\_matrix}}\label{quat_to_matrix}

\texttt{quat\_to\_matrix\ Q} → 3×3 rotation matrix.

\section{\texorpdfstring{\texttt{quat\_from\_matrix}}{quat\_from\_matrix}}\label{quat_from_matrix}

\texttt{quat\_from\_matrix\ R} --- Shepherd\textquotesingle s algorithm.

\section{\texorpdfstring{\texttt{quat\_slerp}}{quat\_slerp}}\label{quat_slerp}

\texttt{quat\_slerp\ A,\ B,\ T} --- spherical-linear interpolation
between two unit quaternions.

\section{\texorpdfstring{\texttt{euler\_zyx\_to\_matrix}}{euler\_zyx\_to\_matrix}}\label{euler_zyx_to_matrix}

\texttt{euler\_zyx\_to\_matrix\ YAW,\ PITCH,\ ROLL} --- intrinsic Z-Y-X
Euler rotation.

\section{\texorpdfstring{\texttt{matrix\_to\_euler\_zyx}}{matrix\_to\_euler\_zyx}}\label{matrix_to_euler_zyx}

\texttt{matrix\_to\_euler\_zyx\ R} → \texttt{{[}yaw,\ pitch,\ roll{]}}.

\section{\texorpdfstring{\texttt{rotate\_3d\_vec}}{rotate\_3d\_vec}}\label{rotate_3d_vec}

\texttt{rotate\_3d\_vec\ Q,\ V} --- apply quaternion rotation to a
3-vector.

\protect\phantomsection\label{ch-information-theory}
\chapter{Information Theory}\label{information-theory}

6 topics

\section{\texorpdfstring{\texttt{kl\_divergence}}{kl\_divergence}}\label{kl_divergence}

\texttt{kl\_divergence\ P,\ Q} --- D\_KL(P \textbar\textbar{} Q) in
nats.

\section{\texorpdfstring{\texttt{js\_divergence}}{js\_divergence}}\label{js_divergence}

\texttt{js\_divergence\ P,\ Q} --- Jensen-Shannon divergence.

\section{\texorpdfstring{\texttt{mutual\_information}}{mutual\_information}}\label{mutual_information}

\texttt{mutual\_information\ JOINT} --- I(X; Y) from a joint-probability
matrix.

\section{\texorpdfstring{\texttt{cross\_entropy\_arr}}{cross\_entropy\_arr}}\label{cross_entropy_arr}

\texttt{cross\_entropy\_arr\ P,\ Q} --- H(P, Q) = -Σ p log q.

\section{\texorpdfstring{\texttt{renyi\_entropy}}{renyi\_entropy}}\label{renyi_entropy}

\texttt{renyi\_entropy\ P\ {[},\ ALPHA{]}} --- Rényi entropy of order α
(default 2).

\section{\texorpdfstring{\texttt{tsallis\_entropy}}{tsallis\_entropy}}\label{tsallis_entropy}

\texttt{tsallis\_entropy\ P\ {[},\ Q{]}} --- Tsallis entropy of order q
(default 2).

\protect\phantomsection\label{ch-quantum-primitives}
\chapter{Quantum Primitives}\label{quantum-primitives}

11 topics

\section{\texorpdfstring{\texttt{pauli\_x}}{pauli\_x}}\label{pauli_x}

\texttt{pauli\_x} --- 2×2 σ\_x matrix.

\section{\texorpdfstring{\texttt{pauli\_y}}{pauli\_y}}\label{pauli_y}

\texttt{pauli\_y} --- 2×2 σ\_y matrix encoded with {[}Re, Im{]} entries
(since stryke matrices are real).

\section{\texorpdfstring{\texttt{pauli\_z}}{pauli\_z}}\label{pauli_z}

\texttt{pauli\_z} --- 2×2 σ\_z matrix.

\section{\texorpdfstring{\texttt{pauli\_id}}{pauli\_id}}\label{pauli_id}

\texttt{pauli\_id} --- 2×2 identity.

\section{\texorpdfstring{\texttt{ket\_bra}}{ket\_bra}}\label{ket_bra}

\texttt{ket\_bra\ PSI,\ PHI} → outer product \textbar ψ⟩⟨φ\textbar{} of
two real vectors.

\section{\texorpdfstring{\texttt{density\_matrix}}{density\_matrix}}\label{density_matrix}

\texttt{density\_matrix\ PSI} → ρ = \textbar ψ⟩⟨ψ\textbar{}
(real-valued).

\section{\texorpdfstring{\texttt{expectation\_value}}{expectation\_value}}\label{expectation_value}

\texttt{expectation\_value\ OP,\ PSI} → ⟨ψ\textbar O\textbar ψ⟩.

\section{\texorpdfstring{\texttt{commutator}}{commutator}}\label{commutator}

\texttt{commutator\ A,\ B} --- {[}A, B{]} = AB − BA.

\section{\texorpdfstring{\texttt{anticommutator}}{anticommutator}}\label{anticommutator}

\texttt{anticommutator\ A,\ B} --- \{A, B\} = AB + BA.

\section{\texorpdfstring{\texttt{partial\_trace}}{partial\_trace}}\label{partial_trace}

\texttt{partial\_trace\ RHO,\ DIMS,\ KEEP} --- partial trace over
subsystems whose indices are not in KEEP.

\section{\texorpdfstring{\texttt{von\_neumann\_entropy}}{von\_neumann\_entropy}}\label{von_neumann_entropy}

\texttt{von\_neumann\_entropy\ RHO} --- S(ρ) = -tr(ρ log ρ) for
symmetric ρ.

\protect\phantomsection\label{ch-statistical-mechanics}
\chapter{Statistical Mechanics}\label{statistical-mechanics}

7 topics

\section{\texorpdfstring{\texttt{bose\_einstein}}{bose\_einstein}}\label{bose_einstein}

\texttt{bose\_einstein\ E,\ MU,\ KT} --- 1 / (exp((E - μ)/kT) - 1).

\section{\texorpdfstring{\texttt{fermi\_dirac}}{fermi\_dirac}}\label{fermi_dirac}

\texttt{fermi\_dirac\ E,\ MU,\ KT} --- 1 / (exp((E - μ)/kT) + 1).

\section{\texorpdfstring{\texttt{maxwell\_boltzmann\_speed}}{maxwell\_boltzmann\_speed}}\label{maxwell_boltzmann_speed}

\texttt{maxwell\_boltzmann\_speed\ V,\ M,\ KT} --- Maxwell-Boltzmann
speed PDF.

\section{\texorpdfstring{\texttt{partition\_function}}{partition\_function}}\label{partition_function}

\texttt{partition\_function\ ENERGIES,\ KT} --- Z = Σ exp(-E\_i / kT).

\section{\texorpdfstring{\texttt{helmholtz\_free\_energy}}{helmholtz\_free\_energy}}\label{helmholtz_free_energy}

\texttt{helmholtz\_free\_energy\ Z,\ KT} --- F = -kT ln Z.

\section{\texorpdfstring{\texttt{boltzmann\_factor}}{boltzmann\_factor}}\label{boltzmann_factor}

\texttt{boltzmann\_factor\ E,\ KT} --- exp(-E / kT).

\section{\texorpdfstring{\texttt{einstein\_specific\_heat}}{einstein\_specific\_heat}}\label{einstein_specific_heat}

\texttt{einstein\_specific\_heat\ T,\ THETA\_E} --- Einstein
heat-capacity model (J / mol·K).

\protect\phantomsection\label{ch-optics}
\chapter{Optics}\label{optics}

7 topics

\section{\texorpdfstring{\texttt{fresnel\_reflection\_te}}{fresnel\_reflection\_te}}\label{fresnel_reflection_te}

\texttt{fresnel\_reflection\_te\ THETA\_I,\ N1,\ N2} --- TE
(s-polarisation) reflection coefficient.

\section{\texorpdfstring{\texttt{fresnel\_reflection\_tm}}{fresnel\_reflection\_tm}}\label{fresnel_reflection_tm}

\texttt{fresnel\_reflection\_tm\ THETA\_I,\ N1,\ N2} --- TM
(p-polarisation) reflection.

\section{\texorpdfstring{\texttt{fresnel\_transmission\_te}}{fresnel\_transmission\_te}}\label{fresnel_transmission_te}

\texttt{fresnel\_transmission\_te\ THETA\_I,\ N1,\ N2} --- TE
transmission.

\section{\texorpdfstring{\texttt{fresnel\_transmission\_tm}}{fresnel\_transmission\_tm}}\label{fresnel_transmission_tm}

\texttt{fresnel\_transmission\_tm\ THETA\_I,\ N1,\ N2} --- TM
transmission.

\section{\texorpdfstring{\texttt{abcd\_thin\_lens}}{abcd\_thin\_lens}}\label{abcd_thin_lens}

\texttt{abcd\_thin\_lens\ F} --- ABCD ray matrix for a thin lens of
focal length F.

\section{\texorpdfstring{\texttt{abcd\_free\_space}}{abcd\_free\_space}}\label{abcd_free_space}

\texttt{abcd\_free\_space\ D} --- ABCD matrix for free-space propagation
D.

\section{\texorpdfstring{\texttt{gaussian\_beam\_q}}{gaussian\_beam\_q}}\label{gaussian_beam_q}

\texttt{gaussian\_beam\_q\ Z,\ W0,\ LAMBDA} →
\texttt{{[}Re(q),\ Im(q){]}} for a Gaussian beam at distance Z.

\protect\phantomsection\label{ch-astrodynamics}
\chapter{Astrodynamics}\label{astrodynamics}

9 topics

\section{\texorpdfstring{\texttt{kepler\_solve}}{kepler\_solve}}\label{kepler_solve}

\texttt{kepler\_solve\ M,\ E} --- solve Kepler\textquotesingle s
equation M = E - e sin(E) by Newton iteration.

\section{\texorpdfstring{\texttt{true\_to\_eccentric}}{true\_to\_eccentric}}\label{true_to_eccentric}

\texttt{true\_to\_eccentric\ NU,\ E} → eccentric anomaly E.

\section{\texorpdfstring{\texttt{eccentric\_to\_mean}}{eccentric\_to\_mean}}\label{eccentric_to_mean}

\texttt{eccentric\_to\_mean\ E,\ ECC} → mean anomaly M.

\section{\texorpdfstring{\texttt{julian\_date}}{julian\_date}}\label{julian_date}

\texttt{julian\_date\ Y,\ M,\ D,\ H,\ MN,\ S} --- Julian date (Meeus
formula).

\section{\texorpdfstring{\texttt{jd\_to\_gregorian}}{jd\_to\_gregorian}}\label{jd_to_gregorian}

\texttt{jd\_to\_gregorian\ JD} → \texttt{{[}Y,\ M,\ D.dd{]}}.

\section{\texorpdfstring{\texttt{sidereal\_time\_gmst}}{sidereal\_time\_gmst}}\label{sidereal_time_gmst}

\texttt{sidereal\_time\_gmst\ JD} --- Greenwich Mean Sidereal Time in
radians.

\section{\texorpdfstring{\texttt{vis\_viva}}{vis\_viva}}\label{vis_viva}

\texttt{vis\_viva\ R,\ A,\ MU} --- orbital speed from vis-viva equation.

\section{\texorpdfstring{\texttt{orbital\_period\_kepler}}{orbital\_period\_kepler}}\label{orbital_period_kepler}

\texttt{orbital\_period\_kepler\ A,\ MU} --- T = 2π √(a³ / μ).

\section{\texorpdfstring{\texttt{orbital\_elements\_to\_state}}{orbital\_elements\_to\_state}}\label{orbital_elements_to_state}

\texttt{orbital\_elements\_to\_state\ A,\ E,\ I,\ OM,\ W,\ NU,\ MU} →
\texttt{{[}r\_x,\ r\_y,\ r\_z,\ v\_x,\ v\_y,\ v\_z{]}}.

\protect\phantomsection\label{ch-time-series}
\chapter{Time Series}\label{time-series}

4 topics

\section{\texorpdfstring{\texttt{kalman\_step}}{kalman\_step}}\label{kalman_step}

\texttt{kalman\_step\ X,\ P,\ F,\ H,\ Q,\ R,\ Z} →
\texttt{{[}X\textquotesingle{},\ P\textquotesingle{}{]}} --- single
Kalman predict-and-update step.

\section{\texorpdfstring{\texttt{exponential\_smoothing}}{exponential\_smoothing}}\label{exponential_smoothing}

\texttt{exponential\_smoothing\ XS,\ ALPHA} --- first-order EMA.

\section{\texorpdfstring{\texttt{holt\_winters}}{holt\_winters}}\label{holt_winters}

\texttt{holt\_winters\ XS,\ ALPHA,\ BETA,\ GAMMA,\ PERIOD} --- additive
triple exponential smoothing.

\section{\texorpdfstring{\texttt{arma\_yw\_fit}}{arma\_yw\_fit}}\label{arma_yw_fit}

\texttt{arma\_yw\_fit\ XS,\ P} --- Yule-Walker AR(p) coefficients via
Levinson-Durbin.

\protect\phantomsection\label{ch-graph-centrality}
\chapter{Graph Centrality}\label{graph-centrality}

6 topics

\section{\texorpdfstring{\texttt{pagerank}}{pagerank}}\label{pagerank}

\texttt{pagerank\ ADJ\ {[},\ DAMPING,\ ITERS{]}} --- PageRank via power
iteration. Default damping 0.85, 100 iters.

\section{\texorpdfstring{\texttt{betweenness\_centrality}}{betweenness\_centrality}}\label{betweenness_centrality}

\texttt{betweenness\_centrality\ ADJ} --- Brandes\textquotesingle{}
algorithm (unweighted).

\section{\texorpdfstring{\texttt{closeness\_centrality}}{closeness\_centrality}}\label{closeness_centrality}

\texttt{closeness\_centrality\ ADJ} --- closeness centrality. 0 for
disconnected vertices.

\section{\texorpdfstring{\texttt{eigenvector\_centrality}}{eigenvector\_centrality}}\label{eigenvector_centrality}

\texttt{eigenvector\_centrality\ ADJ} --- power iteration on the
adjacency matrix.

\section{\texorpdfstring{\texttt{degree\_centrality}}{degree\_centrality}}\label{degree_centrality}

\texttt{degree\_centrality\ ADJ} --- degree / (n - 1).

\section{\texorpdfstring{\texttt{triangle\_count}}{triangle\_count}}\label{triangle_count}

\texttt{triangle\_count\ ADJ} --- number of triangles incident at each
vertex.

\protect\phantomsection\label{ch-random-samplers-extended}
\chapter{Random Samplers (Extended)}\label{random-samplers-extended}

6 topics

\section{\texorpdfstring{\texttt{rgumbel}}{rgumbel}}\label{rgumbel}

\texttt{rgumbel\ MU,\ BETA} --- Gumbel sample.

\section{\texorpdfstring{\texttt{rfrechet}}{rfrechet}}\label{rfrechet}

\texttt{rfrechet\ ALPHA,\ S} --- Fréchet sample.

\section{\texorpdfstring{\texttt{rrayleigh}}{rrayleigh}}\label{rrayleigh}

\texttt{rrayleigh\ SIGMA} --- Rayleigh sample.

\section{\texorpdfstring{\texttt{rlogistic}}{rlogistic}}\label{rlogistic}

\texttt{rlogistic\ MU,\ S} --- logistic sample.

\section{\texorpdfstring{\texttt{rkumaraswamy}}{rkumaraswamy}}\label{rkumaraswamy}

\texttt{rkumaraswamy\ A,\ B} --- Kumaraswamy sample on (0, 1).

\section{\texorpdfstring{\texttt{rinverse\_gamma}}{rinverse\_gamma}}\label{rinverse_gamma}

\texttt{rinverse\_gamma\ ALPHA,\ BETA} --- inverse-gamma sample
(Marsaglia-Tsang).

\protect\phantomsection\label{ch-2-d-geometry}
\chapter{2-D Geometry}\label{d-geometry}

3 topics

\section{\texorpdfstring{\texttt{graham\_scan}}{graham\_scan}}\label{graham_scan}

\texttt{graham\_scan\ POINTS} --- 2-D convex hull (CCW).

\section{\texorpdfstring{\texttt{line\_line\_intersect\_2d}}{line\_line\_intersect\_2d}}\label{line_line_intersect_2d}

\texttt{line\_line\_intersect\_2d\ P1,\ P2,\ P3,\ P4} → intersection
\texttt{{[}x,\ y{]}} or undef when parallel.

\section{\texorpdfstring{\texttt{point\_segment\_distance}}{point\_segment\_distance}}\label{point_segment_distance}

\texttt{point\_segment\_distance\ P,\ A,\ B} --- Euclidean distance from
P to segment AB.

\protect\phantomsection\label{ch-auto-differentiation}
\chapter{Auto-Differentiation}\label{auto-differentiation}

2 topics

\section{\texorpdfstring{\texttt{forward\_diff}}{forward\_diff}}\label{forward_diff}

\texttt{forward\_diff\ F,\ X} --- derivative of scalar f at scalar x
(Julia ForwardDiff style; central-difference fallback).

\section{\texorpdfstring{\texttt{forward\_diff\_grad}}{forward\_diff\_grad}}\label{forward_diff_grad}

\texttt{forward\_diff\_grad\ F,\ X\_VEC} --- gradient at vector x; alias
for \texttt{numerical\_gradient}.

\protect\phantomsection\label{ch-statistical-tests-r-parity}
\chapter{Statistical Tests (R parity)}\label{statistical-tests-r-parity}

12 topics

\section{\texorpdfstring{\texttt{bartlett\_test}}{bartlett\_test}}\label{bartlett_test}

\texttt{bartlett\_test\ GROUPS} --- Bartlett\textquotesingle s k-sample
variance equality test. Returns \texttt{{[}chi²,\ df,\ p{]}}.

\section{\texorpdfstring{\texttt{levene\_test}}{levene\_test}}\label{levene_test}

\texttt{levene\_test\ GROUPS} --- Levene\textquotesingle s
variance-equality test. Returns \texttt{{[}F,\ df1,\ df2,\ p{]}}.

\section{\texorpdfstring{\texttt{fishers\_exact\_test\_2x2}}{fishers\_exact\_test\_2x2}}\label{fishers_exact_test_2x2}

\texttt{fishers\_exact\_test\_2x2\ {[}{[}a,\ b{]},\ {[}c,\ d{]}{]}} ---
two-sided p-value.

\section{\texorpdfstring{\texttt{mcnemar\_test}}{mcnemar\_test}}\label{mcnemar_test}

\texttt{mcnemar\_test\ {[}{[}a,\ b{]},\ {[}c,\ d{]}{]}} --- paired 2×2
table with continuity correction. Returns \texttt{{[}chi²,\ p{]}}.

\section{\texorpdfstring{\texttt{runs\_test}}{runs\_test}}\label{runs_test}

\texttt{runs\_test\ SEQ} --- Wald-Wolfowitz runs test on a binary
sequence. Returns \texttt{{[}Z,\ p{]}}.

\section{\texorpdfstring{\texttt{friedman\_test}}{friedman\_test}}\label{friedman_test}

\texttt{friedman\_test\ BLOCKS\_BY\_TREATMENTS} --- non-parametric ANOVA
on ranks. Returns \texttt{{[}Q,\ df,\ p{]}}.

\section{\texorpdfstring{\texttt{kruskal\_wallis\_test}}{kruskal\_wallis\_test}}\label{kruskal_wallis_test}

\texttt{kruskal\_wallis\_test\ GROUPS} --- non-parametric ANOVA. Returns
\texttt{{[}H,\ df,\ p{]}}.

\section{\texorpdfstring{\texttt{sign\_test}}{sign\_test}}\label{sign_test}

\texttt{sign\_test\ PAIRS} --- paired sign test. Returns
\texttt{{[}N+,\ p{]}}.

\section{\texorpdfstring{\texttt{anderson\_darling\_normality}}{anderson\_darling\_normality}}\label{anderson_darling_normality}

\texttt{anderson\_darling\_normality\ XS} --- A² statistic.
\textgreater{} 0.752 → reject normality at α=0.05.

\section{\texorpdfstring{\texttt{jarque\_bera\_test}}{jarque\_bera\_test}}\label{jarque_bera_test}

\texttt{jarque\_bera\_test\ XS} --- normality test from sample skewness
+ kurtosis.

\section{\texorpdfstring{\texttt{ljung\_box\_test}}{ljung\_box\_test}}\label{ljung_box_test}

\texttt{ljung\_box\_test\ XS\ {[},\ H{]}} --- autocorrelation test.
Returns \texttt{{[}Q,\ h,\ p{]}}.

\section{\texorpdfstring{\texttt{durbin\_watson\_stat}}{durbin\_watson\_stat}}\label{durbin_watson_stat}

\texttt{durbin\_watson\_stat\ RESID} --- DW autocorrelation statistic on
residuals.

\protect\phantomsection\label{ch-distance-metrics-distances-jl-parity}
\chapter{Distance Metrics (Distances.jl
parity)}\label{distance-metrics-distances.jl-parity}

6 topics

\section{\texorpdfstring{\texttt{mahalanobis\_distance}}{mahalanobis\_distance}}\label{mahalanobis_distance}

\texttt{mahalanobis\_distance\ X,\ MU,\ SIGMA} --- √((x-μ)ᵀ Σ⁻¹ (x-μ)).

\section{\texorpdfstring{\texttt{cosine\_distance}}{cosine\_distance}}\label{cosine_distance}

\texttt{cosine\_distance\ A,\ B} --- 1 − cos(A, B).

\section{\texorpdfstring{\texttt{canberra\_distance}}{canberra\_distance}}\label{canberra_distance}

\texttt{canberra\_distance\ A,\ B} --- Σ \textbar a-b\textbar{} /
(\textbar a\textbar+\textbar b\textbar).

\section{\texorpdfstring{\texttt{bray\_curtis\_distance}}{bray\_curtis\_distance}}\label{bray_curtis_distance}

\texttt{bray\_curtis\_distance\ A,\ B} --- Σ\textbar a-b\textbar{} /
Σ(a+b).

\section{\texorpdfstring{\texttt{l1\_distance}}{l1\_distance}}\label{l1_distance}

\texttt{l1\_distance\ A,\ B} --- Manhattan / taxi-cab distance.

\section{\texorpdfstring{\texttt{chi\_squared\_distance}}{chi\_squared\_distance}}\label{chi_squared_distance}

\texttt{chi\_squared\_distance\ A,\ B} --- ½ Σ (a-b)² / (a+b).

\protect\phantomsection\label{ch-multivariate-non-central-distributions}
\chapter{Multivariate / Non-Central
Distributions}\label{multivariate-non-central-distributions}

9 topics

\section{\texorpdfstring{\texttt{multivariate\_normal\_pdf}}{multivariate\_normal\_pdf}}\label{multivariate_normal_pdf}

\texttt{multivariate\_normal\_pdf\ X,\ MU,\ SIGMA} --- multivariate
Gaussian PDF.

\section{\texorpdfstring{\texttt{multivariate\_normal\_sample}}{multivariate\_normal\_sample}}\label{multivariate_normal_sample}

\texttt{multivariate\_normal\_sample\ MU,\ SIGMA} --- sample from MVN
via Cholesky.

\section{\texorpdfstring{\texttt{dirichlet\_pdf}}{dirichlet\_pdf}}\label{dirichlet_pdf}

\texttt{dirichlet\_pdf\ X,\ ALPHA} --- Dirichlet PDF on the simplex.

\section{\texorpdfstring{\texttt{dirichlet\_sample}}{dirichlet\_sample}}\label{dirichlet_sample}

\texttt{dirichlet\_sample\ ALPHA} --- sample via independent Gamma
draws.

\section{\texorpdfstring{\texttt{skellam\_pmf}}{skellam\_pmf}}\label{skellam_pmf}

\texttt{skellam\_pmf\ K,\ MU1,\ MU2} --- difference of two independent
Poisson(μ) variates.

\section{\texorpdfstring{\texttt{inverse\_gaussian\_pdf}}{inverse\_gaussian\_pdf}}\label{inverse_gaussian_pdf}

\texttt{inverse\_gaussian\_pdf\ X,\ MU,\ LAMBDA} --- Wald PDF.

\section{\texorpdfstring{\texttt{inverse\_gaussian\_cdf}}{inverse\_gaussian\_cdf}}\label{inverse_gaussian_cdf}

\texttt{inverse\_gaussian\_cdf\ X,\ MU,\ LAMBDA} --- Wald CDF.

\section{\texorpdfstring{\texttt{inverse\_gaussian\_sample}}{inverse\_gaussian\_sample}}\label{inverse_gaussian_sample}

\texttt{inverse\_gaussian\_sample\ MU,\ LAMBDA} ---
Michael-Schucany-Haas.

\section{\texorpdfstring{\texttt{non\_central\_chi2\_pdf}}{non\_central\_chi2\_pdf}}\label{non_central_chi2_pdf}

\texttt{non\_central\_chi2\_pdf\ X,\ K,\ LAMBDA} --- Series-form
non-central χ² PDF.

\protect\phantomsection\label{ch-matrix-functions}
\chapter{Matrix Functions}\label{matrix-functions}

5 topics

\section{\texorpdfstring{\texttt{matrix\_exp}}{matrix\_exp}}\label{matrix_exp}

\texttt{matrix\_exp\ A} --- e\^{}A via 13-term Padé +
scaling-and-squaring.

\section{\texorpdfstring{\texttt{matrix\_log}}{matrix\_log}}\label{matrix_log}

\texttt{matrix\_log\ A} --- ln A via inverse scaling (Denman-Beavers
SQRT) + Padé log.

\section{\texorpdfstring{\texttt{matrix\_sqrt}}{matrix\_sqrt}}\label{matrix_sqrt}

\texttt{matrix\_sqrt\ A} --- A\^{}(1/2) via Denman-Beavers iteration.

\section{\texorpdfstring{\texttt{matrix\_sin}}{matrix\_sin}}\label{matrix_sin}

\texttt{matrix\_sin\ A} --- series form Σ (-1)\^{}k A\^{}(2k+1) /
(2k+1)!.

\section{\texorpdfstring{\texttt{matrix\_cos}}{matrix\_cos}}\label{matrix_cos}

\texttt{matrix\_cos\ A} --- series form Σ (-1)\^{}k A\^{}(2k) / (2k)!.

\protect\phantomsection\label{ch-adaptive-ode-solvers}
\chapter{Adaptive ODE Solvers}\label{adaptive-ode-solvers}

4 topics

\section{\texorpdfstring{\texttt{rk45\_dormand\_prince}}{rk45\_dormand\_prince}}\label{rk45_dormand_prince}

\texttt{rk45\_dormand\_prince\ F,\ Y0,\ T0,\ T1,\ H0\ {[},\ TOL{]}} ---
adaptive Dormand-Prince. F receives \texttt{{[}t,\ y0,\ …{]}}.

\section{\texorpdfstring{\texttt{midpoint\_step}}{midpoint\_step}}\label{midpoint_step}

\texttt{midpoint\_step\ F,\ Y,\ T,\ H} --- single explicit-midpoint
step.

\section{\texorpdfstring{\texttt{heun\_step}}{heun\_step}}\label{heun_step}

\texttt{heun\_step\ F,\ Y,\ T,\ H} --- improved-Euler / Heun step.

\section{\texorpdfstring{\texttt{verlet\_step}}{verlet\_step}}\label{verlet_step}

\texttt{verlet\_step\ ACCEL,\ Q,\ P,\ T,\ H} --- velocity-Verlet
symplectic step.

\protect\phantomsection\label{ch-generalized-linear-models}
\chapter{Generalized Linear Models}\label{generalized-linear-models}

4 topics

\section{\texorpdfstring{\texttt{logistic\_regression}}{logistic\_regression}}\label{logistic_regression}

\texttt{logistic\_regression\ X,\ Y} --- IRLS (no intercept added ---
supply column of ones).

\section{\texorpdfstring{\texttt{poisson\_regression}}{poisson\_regression}}\label{poisson_regression}

\texttt{poisson\_regression\ X,\ Y} --- IRLS with log link.

\section{\texorpdfstring{\texttt{ridge\_regression}}{ridge\_regression}}\label{ridge_regression}

\texttt{ridge\_regression\ X,\ Y\ {[},\ LAMBDA{]}} ---
Tikhonov-regularised LSQ.

\section{\texorpdfstring{\texttt{lasso\_coord}}{lasso\_coord}}\label{lasso_coord}

\texttt{lasso\_coord\ X,\ Y\ {[},\ LAMBDA,\ MAX\_ITER{]}} ---
coordinate-descent LASSO.

\protect\phantomsection\label{ch-bootstrap-resampling}
\chapter{Bootstrap \& Resampling}\label{bootstrap-resampling}

3 topics

\section{\texorpdfstring{\texttt{bootstrap\_mean\_ci}}{bootstrap\_mean\_ci}}\label{bootstrap_mean_ci}

\texttt{bootstrap\_mean\_ci\ DATA\ {[},\ B,\ ALPHA{]}} --- percentile CI
for the mean.

\section{\texorpdfstring{\texttt{jackknife\_estimate}}{jackknife\_estimate}}\label{jackknife_estimate}

\texttt{jackknife\_estimate\ DATA} --- leave-one-out SE of the mean.

\section{\texorpdfstring{\texttt{permutation\_test\_diff}}{permutation\_test\_diff}}\label{permutation_test_diff}

\texttt{permutation\_test\_diff\ A,\ B\ {[},\ N\_ITER{]}} --- two-sided
p of mean difference.

\protect\phantomsection\label{ch-time-series-operators}
\chapter{Time Series Operators}\label{time-series-operators}

4 topics

\section{\texorpdfstring{\texttt{acf\_at\_lag}}{acf\_at\_lag}}\label{acf_at_lag}

\texttt{acf\_at\_lag\ XS,\ LAG} --- autocorrelation at one lag.

\section{\texorpdfstring{\texttt{diff\_op}}{diff\_op}}\label{diff_op}

\texttt{diff\_op\ XS\ {[},\ LAG{]}} --- y\_t − y\_\{t-lag\}.

\section{\texorpdfstring{\texttt{lag\_op}}{lag\_op}}\label{lag_op}

\texttt{lag\_op\ XS\ {[},\ K{]}} --- shift by k (NaN-pad).

\section{\texorpdfstring{\texttt{decompose\_classical}}{decompose\_classical}}\label{decompose_classical}

\texttt{decompose\_classical\ XS\ {[},\ PERIOD{]}} --- additive
{[}trend, season, residual{]}.

\protect\phantomsection\label{ch-combinatorial-generators}
\chapter{Combinatorial Generators}\label{combinatorial-generators}

4 topics

\section{\texorpdfstring{\texttt{combinations\_list}}{combinations\_list}}\label{combinations_list}

\texttt{combinations\_list\ N,\ K} --- all k-subsets of 0..n in lex
order.

\section{\texorpdfstring{\texttt{permutations\_list}}{permutations\_list}}\label{permutations_list}

\texttt{permutations\_list\ N} --- all permutations of 0..n via
Heap\textquotesingle s algorithm.

\section{\texorpdfstring{\texttt{cyclic\_permutations}}{cyclic\_permutations}}\label{cyclic_permutations}

\texttt{cyclic\_permutations\ ARR} --- all rotations.

\section{\texorpdfstring{\texttt{subsets\_of\_size}}{subsets\_of\_size}}\label{subsets_of_size}

\texttt{subsets\_of\_size\ ARR,\ K} --- all k-subsets of an arbitrary
array.

\protect\phantomsection\label{ch-dynamic-programming}
\chapter{Dynamic Programming}\label{dynamic-programming}

5 topics

\section{\texorpdfstring{\texttt{longest\_increasing\_subseq}}{longest\_increasing\_subseq}}\label{longest_increasing_subseq}

\texttt{longest\_increasing\_subseq\ XS} --- length only (O(n log n)).

\section{\texorpdfstring{\texttt{knapsack\_01}}{knapsack\_01}}\label{knapsack_01}

\texttt{knapsack\_01\ ITEMS,\ CAPACITY} --- items as
\texttt{{[}{[}w,\ v{]},\ …{]}}.

\section{\texorpdfstring{\texttt{subset\_sum\_target}}{subset\_sum\_target}}\label{subset_sum_target}

\texttt{subset\_sum\_target\ ARR,\ T} --- 1 if any subset sums to T.

\section{\texorpdfstring{\texttt{coin\_change\_min}}{coin\_change\_min}}\label{coin_change_min}

\texttt{coin\_change\_min\ COINS,\ N} --- min number of coins to make N
(-1 if impossible).

\section{\texorpdfstring{\texttt{edit\_distance\_levenshtein}}{edit\_distance\_levenshtein}}\label{edit_distance_levenshtein}

\texttt{edit\_distance\ A,\ B} --- Levenshtein distance.

\protect\phantomsection\label{ch-ml-metrics}
\chapter{ML Metrics}\label{ml-metrics}

5 topics

\section{\texorpdfstring{\texttt{one\_hot\_encode}}{one\_hot\_encode}}\label{one_hot_encode}

\texttt{one\_hot\_encode\ LABELS\ {[},\ N\_CLASSES{]}} → n×K matrix.

\section{\texorpdfstring{\texttt{label\_encode}}{label\_encode}}\label{label_encode}

\texttt{label\_encode\ ARR} → \texttt{{[}indices,\ classes{]}}.

\section{\texorpdfstring{\texttt{categorical\_cross\_entropy}}{categorical\_cross\_entropy}}\label{categorical_cross_entropy}

\texttt{categorical\_cross\_entropy\ Y\_TRUE,\ Y\_PRED} --- averaged
over batch.

\section{\texorpdfstring{\texttt{classification\_metrics}}{classification\_metrics}}\label{classification_metrics}

\texttt{classification\_metrics\ TP,\ FP,\ FN,\ TN} →
\texttt{{[}acc,\ prec,\ recall,\ f1{]}}.

\section{\texorpdfstring{\texttt{roc\_auc}}{roc\_auc}}\label{roc_auc}

\texttt{roc\_auc\ SCORES,\ LABELS} --- Mann-Whitney U / (n+ n−).

\protect\phantomsection\label{ch-dsp-image-filters}
\chapter{DSP / Image Filters}\label{dsp-image-filters}

6 topics

\section{\texorpdfstring{\texttt{gaussian\_blur\_kernel}}{gaussian\_blur\_kernel}}\label{gaussian_blur_kernel}

\texttt{gaussian\_blur\_kernel\ SIGMA\ {[},\ RADIUS{]}} --- 1-D
normalized kernel.

\section{\texorpdfstring{\texttt{sobel\_x}}{sobel\_x}}\label{sobel_x}

\texttt{sobel\_x} --- horizontal Sobel kernel.

\section{\texorpdfstring{\texttt{sobel\_y}}{sobel\_y}}\label{sobel_y}

\texttt{sobel\_y} --- vertical Sobel kernel.

\section{\texorpdfstring{\texttt{prewitt\_x}}{prewitt\_x}}\label{prewitt_x}

\texttt{prewitt\_x} --- horizontal Prewitt.

\section{\texorpdfstring{\texttt{prewitt\_y}}{prewitt\_y}}\label{prewitt_y}

\texttt{prewitt\_y} --- vertical Prewitt.

\section{\texorpdfstring{\texttt{laplacian\_of\_gaussian}}{laplacian\_of\_gaussian}}\label{laplacian_of_gaussian}

\texttt{laplacian\_of\_gaussian\ SIGMA} --- 2-D LoG kernel.

\protect\phantomsection\label{ch-stochastic-processes}
\chapter{Stochastic Processes}\label{stochastic-processes}

4 topics

\section{\texorpdfstring{\texttt{brownian\_path}}{brownian\_path}}\label{brownian_path}

\texttt{brownian\_path\ T,\ N} --- discrete Wiener path on {[}0, T{]}.

\section{\texorpdfstring{\texttt{geometric\_brownian\_path}}{geometric\_brownian\_path}}\label{geometric_brownian_path}

\texttt{geometric\_brownian\_path\ S0,\ MU,\ SIGMA,\ T,\ N} --- GBM
sample path.

\section{\texorpdfstring{\texttt{poisson\_process}}{poisson\_process}}\label{poisson_process}

\texttt{poisson\_process\ LAMBDA,\ T} --- homogeneous Poisson arrival
times.

\section{\texorpdfstring{\texttt{random\_walk\_1d}}{random\_walk\_1d}}\label{random_walk_1d}

\texttt{random\_walk\_1d\ N\ {[},\ P{]}} --- ±1 walk over N steps.

\protect\phantomsection\label{ch-compression-information-complexity}
\chapter{Compression / Information
Complexity}\label{compression-information-complexity}

3 topics

\section{\texorpdfstring{\texttt{lempel\_ziv\_complexity}}{lempel\_ziv\_complexity}}\label{lempel_ziv_complexity}

\texttt{lempel\_ziv\_complexity\ SEQ} --- LZ76 production count.

\section{\texorpdfstring{\texttt{huffman\_code\_lengths}}{huffman\_code\_lengths}}\label{huffman_code_lengths}

\texttt{huffman\_code\_lengths\ FREQS} --- code-length per symbol.

\section{\texorpdfstring{\texttt{shannon\_entropy\_rate}}{shannon\_entropy\_rate}}\label{shannon_entropy_rate}

\texttt{shannon\_entropy\_rate\ SEQ\ {[},\ M{]}} --- H\_m − H\_\{m-1\}
block estimate.

\protect\phantomsection\label{ch-physics-quantum-extended}
\chapter{Physics \& Quantum (Extended)}\label{physics-quantum-extended}

5 topics

\section{\texorpdfstring{\texttt{planck\_blackbody}}{planck\_blackbody}}\label{planck_blackbody}

\texttt{planck\_blackbody\ LAMBDA,\ T} --- spectral radiance B(λ, T).

\section{\texorpdfstring{\texttt{rayleigh\_jeans}}{rayleigh\_jeans}}\label{rayleigh_jeans}

\texttt{rayleigh\_jeans\ LAMBDA,\ T} --- long-wavelength approx.

\section{\texorpdfstring{\texttt{compton\_shift}}{compton\_shift}}\label{compton_shift}

\texttt{compton\_shift\ THETA} --- photon wavelength shift Δλ = (h/m\_e
c)(1-cosθ).

\section{\texorpdfstring{\texttt{rydberg\_energy}}{rydberg\_energy}}\label{rydberg_energy}

\texttt{rydberg\_energy\ N} --- hydrogen level energy −13.605693/n² eV.

\section{\texorpdfstring{\texttt{hydrogen\_radial\_wavefunction}}{hydrogen\_radial\_wavefunction}}\label{hydrogen_radial_wavefunction}

\texttt{hydrogen\_radial\_wavefunction\ N,\ L,\ R} --- atomic-units
R\_\{n,l\}(r).

\protect\phantomsection\label{ch-number-theory-algebra-extended}
\chapter{Number Theory \& Algebra
(Extended)}\label{number-theory-algebra-extended}

5 topics

\section{\texorpdfstring{\texttt{integer\_log}}{integer\_log}}\label{integer_log}

\texttt{integer\_log\ N\ {[},\ BASE{]}} --- largest k with base\^{}k ≤
n.

\section{\texorpdfstring{\texttt{aks\_primality}}{aks\_primality}}\label{aks_primality}

\texttt{aks\_primality\ N} --- deterministic primality (perfect-power +
small-factor + Miller-Rabin fallback).

\section{\texorpdfstring{\texttt{elliptic\_curve\_add}}{elliptic\_curve\_add}}\label{elliptic_curve_add}

\texttt{elliptic\_curve\_add\ P,\ Q,\ A,\ B} --- group law on y² = x³ +
a x + b. Identity = \texttt{{[}NaN,\ NaN{]}}.

\section{\texorpdfstring{\texttt{berlekamp\_massey}}{berlekamp\_massey}}\label{berlekamp_massey}

\texttt{berlekamp\_massey\ SEQ} --- minimal-LFSR connection-polynomial
coefficients.

\section{\texorpdfstring{\texttt{bezout\_coefficients}}{bezout\_coefficients}}\label{bezout_coefficients}

\texttt{bezout\_coefficients\ A,\ B} → \texttt{{[}gcd,\ x,\ y{]}} with a
x + b y = gcd.

\protect\phantomsection\label{ch-cas-lite}
\chapter{CAS-Lite}\label{cas-lite}

3 topics

\section{\texorpdfstring{\texttt{factor\_quadratic}}{factor\_quadratic}}\label{factor_quadratic}

\texttt{factor\_quadratic\ A,\ B,\ C} --- real roots of a x² + b x + c =
0.

\section{\texorpdfstring{\texttt{complete\_square}}{complete\_square}}\label{complete_square}

\texttt{complete\_square\ A,\ B,\ C} → \texttt{{[}h,\ k{]}} for a (x-h)²
+ k.

\section{\texorpdfstring{\texttt{partial\_fraction\_simple}}{partial\_fraction\_simple}}\label{partial_fraction_simple}

\texttt{partial\_fraction\_simple\ NUM,\ ROOTS} --- Heaviside cover-up
residues.

\protect\phantomsection\label{ch-quadrature-specialised}
\chapter{Quadrature (Specialised)}\label{quadrature-specialised}

7 topics

\section{\texorpdfstring{\texttt{gauss\_chebyshev\_quad}}{gauss\_chebyshev\_quad}}\label{gauss_chebyshev_quad}

\texttt{gauss\_chebyshev\_quad\ F\ {[},\ N{]}} --- ∫\_\{-1\}\^{}1
f(x)/√(1-x²) dx (default N=16).

\section{\texorpdfstring{\texttt{gauss\_hermite\_quad}}{gauss\_hermite\_quad}}\label{gauss_hermite_quad}

\texttt{gauss\_hermite\_quad\ F\ {[},\ N{]}} --- ∫\_\{-∞\}\^{}∞ f(x)
e\^{}\{-x²\} dx (default N=20).

\section{\texorpdfstring{\texttt{gauss\_laguerre\_quad}}{gauss\_laguerre\_quad}}\label{gauss_laguerre_quad}

\texttt{gauss\_laguerre\_quad\ F\ {[},\ N{]}} --- ∫\_0\^{}∞ f(x)
e\^{}\{-x\} dx (default N=20).

\section{\texorpdfstring{\texttt{clenshaw\_curtis\_quad}}{clenshaw\_curtis\_quad}}\label{clenshaw_curtis_quad}

\texttt{clenshaw\_curtis\_quad\ F,\ A,\ B\ {[},\ N{]}} ---
Chebyshev-node quadrature.

\section{\texorpdfstring{\texttt{tanh\_sinh\_quad}}{tanh\_sinh\_quad}}\label{tanh_sinh_quad}

\texttt{tanh\_sinh\_quad\ F,\ A,\ B\ {[},\ LEVELS{]}} ---
double-exponential quadrature.

\section{\texorpdfstring{\texttt{gauss\_legendre\_2d}}{gauss\_legendre\_2d}}\label{gauss_legendre_2d}

\texttt{gauss\_legendre\_2d\ F,\ AX,\ BX,\ AY,\ BY\ {[},\ N{]}} ---
Cartesian-product GL.

\section{\texorpdfstring{\texttt{monte\_carlo\_2d}}{monte\_carlo\_2d}}\label{monte_carlo_2d}

\texttt{monte\_carlo\_2d\ F,\ AX,\ BX,\ AY,\ BY\ {[},\ N{]}} --- uniform
Monte Carlo on a rectangle.

\protect\phantomsection\label{ch-optimization-heuristic}
\chapter{Optimization (Heuristic)}\label{optimization-heuristic}

3 topics

\section{\texorpdfstring{\texttt{simulated\_annealing}}{simulated\_annealing}}\label{simulated_annealing}

\texttt{simulated\_annealing\ F,\ X0\ {[},\ T0,\ COOL,\ ITERS,\ STEP{]}}
--- Metropolis-Hastings minimisation.

\section{\texorpdfstring{\texttt{simplex\_lp}}{simplex\_lp}}\label{simplex_lp}

\texttt{simplex\_lp\ C,\ A,\ B} --- max cᵀx s.t. Ax ≤ b, x ≥ 0. Returns
\texttt{{[}x,\ value{]}}.

\section{\texorpdfstring{\texttt{particle\_swarm}}{particle\_swarm}}\label{particle_swarm}

\texttt{particle\_swarm\ F,\ BOUNDS,\ SWARM,\ ITERS} ---
constriction-coefficient PSO.

\protect\phantomsection\label{ch-distributions-tail-mixture-categorical}
\chapter{Distributions (Tail / Mixture /
Categorical)}\label{distributions-tail-mixture-categorical}

14 topics

\section{\texorpdfstring{\texttt{gev\_pdf}}{gev\_pdf}}\label{gev_pdf}

\texttt{gev\_pdf\ X,\ MU,\ SIGMA,\ XI} --- Generalised Extreme Value
PDF.

\section{\texorpdfstring{\texttt{gev\_cdf}}{gev\_cdf}}\label{gev_cdf}

\texttt{gev\_cdf\ X,\ MU,\ SIGMA,\ XI} --- GEV CDF.

\section{\texorpdfstring{\texttt{gev\_sample}}{gev\_sample}}\label{gev_sample}

\texttt{gev\_sample\ MU,\ SIGMA,\ XI} --- GEV sample.

\section{\texorpdfstring{\texttt{gen\_pareto\_pdf}}{gen\_pareto\_pdf}}\label{gen_pareto_pdf}

\texttt{gen\_pareto\_pdf\ X,\ MU,\ SIGMA,\ XI} --- Generalised Pareto
PDF.

\section{\texorpdfstring{\texttt{gen\_pareto\_cdf}}{gen\_pareto\_cdf}}\label{gen_pareto_cdf}

\texttt{gen\_pareto\_cdf\ X,\ MU,\ SIGMA,\ XI} --- GP CDF.

\section{\texorpdfstring{\texttt{gen\_pareto\_sample}}{gen\_pareto\_sample}}\label{gen_pareto_sample}

\texttt{gen\_pareto\_sample\ MU,\ SIGMA,\ XI} --- GP sample.

\section{\texorpdfstring{\texttt{skew\_normal\_pdf}}{skew\_normal\_pdf}}\label{skew_normal_pdf}

\texttt{skew\_normal\_pdf\ X,\ XI,\ OMEGA,\ ALPHA} --- Azzalini
skew-normal PDF.

\section{\texorpdfstring{\texttt{skew\_normal\_cdf}}{skew\_normal\_cdf}}\label{skew_normal_cdf}

\texttt{skew\_normal\_cdf\ X,\ XI,\ OMEGA,\ ALPHA} --- skew-normal CDF
(numeric integration).

\section{\texorpdfstring{\texttt{mixture\_normal\_pdf}}{mixture\_normal\_pdf}}\label{mixture_normal_pdf}

\texttt{mixture\_normal\_pdf\ X,\ WEIGHTS,\ MEANS,\ STDS} ---
Gaussian-mixture PDF.

\section{\texorpdfstring{\texttt{categorical\_sample}}{categorical\_sample}}\label{categorical_sample}

\texttt{categorical\_sample\ PROBS} --- sample category index.

\section{\texorpdfstring{\texttt{multinomial\_pmf}}{multinomial\_pmf}}\label{multinomial_pmf}

\texttt{multinomial\_pmf\ COUNTS,\ PROBS} --- multinomial PMF.

\section{\texorpdfstring{\texttt{multinomial\_sample}}{multinomial\_sample}}\label{multinomial_sample}

\texttt{multinomial\_sample\ N,\ PROBS} --- multinomial counts vector.

\section{\texorpdfstring{\texttt{truncated\_normal\_pdf}}{truncated\_normal\_pdf}}\label{truncated_normal_pdf}

\texttt{truncated\_normal\_pdf\ X,\ MU,\ SIGMA,\ LO,\ HI} ---
truncated-normal PDF.

\section{\texorpdfstring{\texttt{truncated\_normal\_sample}}{truncated\_normal\_sample}}\label{truncated_normal_sample}

\texttt{truncated\_normal\_sample\ MU,\ SIGMA,\ LO,\ HI} --- rejection
sampler.

\protect\phantomsection\label{ch-clustering-dimensionality-reduction}
\chapter{Clustering \& Dimensionality
Reduction}\label{clustering-dimensionality-reduction}

7 topics

\section{\texorpdfstring{\texttt{dbscan}}{dbscan}}\label{dbscan}

\texttt{dbscan\ POINTS,\ EPS,\ MIN\_PTS} --- density-based clustering.
Returns label per point (-1 = noise).

\section{\texorpdfstring{\texttt{gmm\_em\_1d}}{gmm\_em\_1d}}\label{gmm_em_1d}

\texttt{gmm\_em\_1d\ DATA,\ K\ {[},\ MAX\_ITER{]}} --- 1-D
Gaussian-mixture EM. Returns \texttt{{[}π,\ μ,\ σ{]}}.

\section{\texorpdfstring{\texttt{silhouette\_score}}{silhouette\_score}}\label{silhouette_score}

\texttt{silhouette\_score\ POINTS,\ LABELS} --- mean silhouette
coefficient.

\section{\texorpdfstring{\texttt{davies\_bouldin\_index}}{davies\_bouldin\_index}}\label{davies_bouldin_index}

\texttt{davies\_bouldin\_index\ POINTS,\ LABELS} --- lower is better.

\section{\texorpdfstring{\texttt{calinski\_harabasz\_index}}{calinski\_harabasz\_index}}\label{calinski_harabasz_index}

\texttt{calinski\_harabasz\_index\ POINTS,\ LABELS} --- higher is
better.

\section{\texorpdfstring{\texttt{mds\_2d}}{mds\_2d}}\label{mds_2d}

\texttt{mds\_2d\ D} --- classical multidimensional scaling on a distance
matrix → 2-D coords.

\section{\texorpdfstring{\texttt{mean\_shift}}{mean\_shift}}\label{mean_shift}

\texttt{mean\_shift\ POINTS\ {[},\ BANDWIDTH,\ MAX\_ITER{]}} ---
non-parametric mode-seeking.

\protect\phantomsection\label{ch-neural-net-primitives}
\chapter{Neural-Net Primitives}\label{neural-net-primitives}

11 topics

\section{\texorpdfstring{\texttt{batch\_norm}}{batch\_norm}}\label{batch_norm}

\texttt{batch\_norm\ XS\ {[},\ EPS{]}} --- zero-mean unit-variance
normalisation.

\section{\texorpdfstring{\texttt{layer\_norm}}{layer\_norm}}\label{layer_norm}

\texttt{layer\_norm\ XS\ {[},\ EPS{]}} --- alias for batch\_norm
(per-sample reuse).

\section{\texorpdfstring{\texttt{dropout\_mask}}{dropout\_mask}}\label{dropout_mask}

\texttt{dropout\_mask\ N\ {[},\ P{]}} --- Bernoulli dropout mask scaled
by 1/(1−p).

\section{\texorpdfstring{\texttt{max\_pool\_1d}}{max\_pool\_1d}}\label{max_pool_1d}

\texttt{max\_pool\_1d\ XS\ {[},\ WIN{]}} --- non-overlapping max-pool.

\section{\texorpdfstring{\texttt{avg\_pool\_1d}}{avg\_pool\_1d}}\label{avg_pool_1d}

\texttt{avg\_pool\_1d\ XS\ {[},\ WIN{]}} --- non-overlapping
average-pool.

\section{\texorpdfstring{\texttt{attention\_softmax}}{attention\_softmax}}\label{attention_softmax}

\texttt{attention\_softmax\ XS} --- numerically stable softmax.

\section{\texorpdfstring{\texttt{positional\_encoding}}{positional\_encoding}}\label{positional_encoding}

\texttt{positional\_encoding\ LENGTH,\ D\_MODEL} --- sinusoidal
Transformer encoding.

\section{\texorpdfstring{\texttt{glorot\_init}}{glorot\_init}}\label{glorot_init}

\texttt{glorot\_init\ FAN\_IN,\ FAN\_OUT} --- Glorot uniform.

\section{\texorpdfstring{\texttt{he\_init}}{he\_init}}\label{he_init}

\texttt{he\_init\ FAN\_IN,\ FAN\_OUT} --- Gaussian (std = √(2/fan\_in)).

\section{\texorpdfstring{\texttt{adam\_step}}{adam\_step}}\label{adam_step}

\texttt{adam\_step\ PARAM,\ GRAD,\ M,\ V,\ LR,\ B1,\ B2,\ EPS,\ T} →
\texttt{{[}param\textquotesingle{},\ m\textquotesingle{},\ v\textquotesingle{}{]}}.

\section{\texorpdfstring{\texttt{rmsprop\_step}}{rmsprop\_step}}\label{rmsprop_step}

\texttt{rmsprop\_step\ PARAM,\ GRAD,\ V,\ LR,\ DECAY,\ EPS} →
\texttt{{[}param\textquotesingle{},\ v\textquotesingle{}{]}}.

\protect\phantomsection\label{ch-time-series-spectral}
\chapter{Time Series (Spectral)}\label{time-series-spectral}

5 topics

\section{\texorpdfstring{\texttt{ewma}}{ewma}}\label{ewma}

\texttt{ewma\ XS\ {[},\ ALPHA{]}} --- exponentially-weighted moving
average.

\section{\texorpdfstring{\texttt{ccf}}{ccf}}\label{ccf}

\texttt{ccf\ XS,\ YS\ {[},\ MAX\_LAG{]}} --- sample cross-correlation
function over -L..L lags.

\section{\texorpdfstring{\texttt{periodogram}}{periodogram}}\label{periodogram}

\texttt{periodogram\ XS} --- squared-magnitude DFT / N (one-sided
spectrum).

\section{\texorpdfstring{\texttt{welch\_psd}}{welch\_psd}}\label{welch_psd}

\texttt{welch\_psd\ XS\ {[},\ SEG\_LEN,\ OVERLAP{]}} ---
Welch\textquotesingle s PSD via Hann segments.

\section{\texorpdfstring{\texttt{lag\_features}}{lag\_features}}\label{lag_features}

\texttt{lag\_features\ XS,\ P} --- design matrix of P lagged features.

\protect\phantomsection\label{ch-image-processing}
\chapter{Image Processing}\label{image-processing}

5 topics

\section{\texorpdfstring{\texttt{median\_filter\_2d}}{median\_filter\_2d}}\label{median_filter_2d}

\texttt{median\_filter\_2d\ IMG\ {[},\ RADIUS{]}} --- denoising median
filter.

\section{\texorpdfstring{\texttt{threshold\_otsu}}{threshold\_otsu}}\label{threshold_otsu}

\texttt{threshold\_otsu\ IMG} --- Otsu\textquotesingle s optimal
threshold for 0..255 grayscale.

\section{\texorpdfstring{\texttt{histogram\_equalize}}{histogram\_equalize}}\label{histogram_equalize}

\texttt{histogram\_equalize\ IMG} --- global histogram equalisation.

\section{\texorpdfstring{\texttt{erode\_2d}}{erode\_2d}}\label{erode_2d}

\texttt{erode\_2d\ IMG\ {[},\ RADIUS{]}} --- morphological erosion
(square structuring element).

\section{\texorpdfstring{\texttt{dilate\_2d}}{dilate\_2d}}\label{dilate_2d}

\texttt{dilate\_2d\ IMG\ {[},\ RADIUS{]}} --- morphological dilation.

\protect\phantomsection\label{ch-loss-functions}
\chapter{Loss Functions}\label{loss-functions}

3 topics

\section{\texorpdfstring{\texttt{mse\_loss}}{mse\_loss}}\label{mse_loss}

\texttt{mse\_loss\ A,\ B} --- mean-squared error.

\section{\texorpdfstring{\texttt{mae\_loss}}{mae\_loss}}\label{mae_loss}

\texttt{mae\_loss\ A,\ B} --- mean-absolute error.

\section{\texorpdfstring{\texttt{huber\_loss}}{huber\_loss}}\label{huber_loss}

\texttt{huber\_loss\ A,\ B\ {[},\ DELTA{]}} --- Huber loss (default
δ=1).

\protect\phantomsection\label{ch-spatial-geographic}
\chapter{Spatial / Geographic}\label{spatial-geographic}

3 topics

\section{\texorpdfstring{\texttt{vincenty\_distance}}{vincenty\_distance}}\label{vincenty_distance}

\texttt{vincenty\_distance\ LAT1,\ LON1,\ LAT2,\ LON2} --- geodesic
distance on WGS-84.

\section{\texorpdfstring{\texttt{mercator\_project}}{mercator\_project}}\label{mercator_project}

\texttt{mercator\_project\ LAT,\ LON\ {[},\ R{]}} → \texttt{{[}x,\ y{]}}
Mercator metres.

\section{\texorpdfstring{\texttt{destination\_from\_bearing}}{destination\_from\_bearing}}\label{destination_from_bearing}

\texttt{destination\_from\_bearing\ LAT,\ LON,\ BEARING\_DEG,\ DIST\_M\ {[},\ R{]}}
--- spherical great-circle target.

\protect\phantomsection\label{ch-integer-sequences}
\chapter{Integer Sequences}\label{integer-sequences}

6 topics

\section{\texorpdfstring{\texttt{recaman}}{recaman}}\label{recaman}

\texttt{recaman\ N} --- first N terms of Recamán\textquotesingle s
sequence.

\section{\texorpdfstring{\texttt{sylvester}}{sylvester}}\label{sylvester}

\texttt{sylvester\ N} --- Sylvester\textquotesingle s sequence (a\_n =
a\_\{n-1\}² − a\_\{n-1\} + 1).

\section{\texorpdfstring{\texttt{happy\_q}}{happy\_q}}\label{happy_q}

\texttt{happy\_q\ N} --- 1 if N is a happy number.

\section{\texorpdfstring{\texttt{amicable\_pair\_q}}{amicable\_pair\_q}}\label{amicable_pair_q}

\texttt{amicable\_pair\_q\ A,\ B} --- 1 if (a, b) is an amicable pair.

\section{\texorpdfstring{\texttt{aliquot\_sequence}}{aliquot\_sequence}}\label{aliquot_sequence}

\texttt{aliquot\_sequence\ N\ {[},\ MAX\_STEPS{]}} ---
sum-of-proper-divisors trajectory.

\section{\texorpdfstring{\texttt{magic\_constant}}{magic\_constant}}\label{magic_constant}

\texttt{magic\_constant\ N} --- n(n²+1)/2 (sum of any line of an n×n
magic square).

\protect\phantomsection\label{ch-graph-link-cluster-metrics}
\chapter{Graph Link \& Cluster
Metrics}\label{graph-link-cluster-metrics}

7 topics

\section{\texorpdfstring{\texttt{clustering\_coefficient\_local}}{clustering\_coefficient\_local}}\label{clustering_coefficient_local}

\texttt{clustering\_coefficient\_local\ ADJ} --- local CC per vertex.

\section{\texorpdfstring{\texttt{clustering\_coefficient\_global}}{clustering\_coefficient\_global}}\label{clustering_coefficient_global}

\texttt{clustering\_coefficient\_global\ ADJ} --- mean local CC.

\section{\texorpdfstring{\texttt{assortativity}}{assortativity}}\label{assortativity}

\texttt{assortativity\ ADJ} --- degree-degree correlation coefficient.

\section{\texorpdfstring{\texttt{common\_neighbors}}{common\_neighbors}}\label{common_neighbors}

\texttt{common\_neighbors\ ADJ,\ U,\ V} --- count.

\section{\texorpdfstring{\texttt{jaccard\_neighbors}}{jaccard\_neighbors}}\label{jaccard_neighbors}

\texttt{jaccard\_neighbors\ ADJ,\ U,\ V} --- \textbar Γ(u) ∩
Γ(v)\textbar{} / \textbar Γ(u) ∪ Γ(v)\textbar.

\section{\texorpdfstring{\texttt{adamic\_adar}}{adamic\_adar}}\label{adamic_adar}

\texttt{adamic\_adar\ ADJ,\ U,\ V} --- Σ 1/log(deg(w)) over common
neighbours w.

\section{\texorpdfstring{\texttt{preferential\_attachment\_score}}{preferential\_attachment\_score}}\label{preferential_attachment_score}

\texttt{preferential\_attachment\_score\ ADJ,\ U,\ V} --- deg(u)·deg(v).

\protect\phantomsection\label{ch-3-d-geometry}
\chapter{3-D Geometry}\label{d-geometry-1}

8 topics

\section{\texorpdfstring{\texttt{triangle\_3d\_normal}}{triangle\_3d\_normal}}\label{triangle_3d_normal}

\texttt{triangle\_3d\_normal\ P1,\ P2,\ P3} --- unit normal.

\section{\texorpdfstring{\texttt{triangle\_3d\_area}}{triangle\_3d\_area}}\label{triangle_3d_area}

\texttt{triangle\_3d\_area\ P1,\ P2,\ P3} --- area via cross product.

\section{\texorpdfstring{\texttt{tetrahedron\_volume}}{tetrahedron\_volume}}\label{tetrahedron_volume}

\texttt{tetrahedron\_volume\ A,\ B,\ C,\ D} --- \textbar det(B-A, C-A,
D-A)\textbar/6.

\section{\texorpdfstring{\texttt{plane\_from\_3\_points}}{plane\_from\_3\_points}}\label{plane_from_3_points}

\texttt{plane\_from\_3\_points\ P1,\ P2,\ P3} →
\texttt{{[}a,\ b,\ c,\ d{]}} (a x + b y + c z + d = 0).

\section{\texorpdfstring{\texttt{point\_to\_plane\_distance}}{point\_to\_plane\_distance}}\label{point_to_plane_distance}

\texttt{point\_to\_plane\_distance\ P,\ {[}a,\ b,\ c,\ d{]}}.

\section{\texorpdfstring{\texttt{ray\_triangle\_intersect}}{ray\_triangle\_intersect}}\label{ray_triangle_intersect}

\texttt{ray\_triangle\_intersect\ O,\ D,\ A,\ B,\ C} ---
Möller-Trumbore. Returns t or NaN.

\section{\texorpdfstring{\texttt{ray\_sphere\_intersect}}{ray\_sphere\_intersect}}\label{ray_sphere_intersect}

\texttt{ray\_sphere\_intersect\ O,\ D,\ CENTER,\ RADIUS} --- nearest
non-negative t.

\section{\texorpdfstring{\texttt{aabb\_overlap}}{aabb\_overlap}}\label{aabb_overlap}

\texttt{aabb\_overlap\ A\_MIN,\ A\_MAX,\ B\_MIN,\ B\_MAX} --- 1 if 3-D
AABBs overlap.

\protect\phantomsection\label{ch-iterative-solvers}
\chapter{Iterative Solvers}\label{iterative-solvers}

6 topics

\section{\texorpdfstring{\texttt{gauss\_seidel}}{gauss\_seidel}}\label{gauss_seidel}

\texttt{gauss\_seidel\ A,\ B\ {[},\ MAX\_ITER,\ TOL{]}} --- Gauss-Seidel
iterative solver.

\section{\texorpdfstring{\texttt{jacobi\_iteration}}{jacobi\_iteration}}\label{jacobi_iteration}

\texttt{jacobi\_iteration\ A,\ B\ {[},\ MAX\_ITER,\ TOL{]}} --- Jacobi
iteration.

\section{\texorpdfstring{\texttt{sor\_solve}}{sor\_solve}}\label{sor_solve}

\texttt{sor\_solve\ A,\ B\ {[},\ OMEGA,\ MAX\_ITER,\ TOL{]}} ---
Successive Over-Relaxation.

\section{\texorpdfstring{\texttt{thomas\_tridiag\_solve}}{thomas\_tridiag\_solve}}\label{thomas_tridiag_solve}

\texttt{thomas\_tridiag\_solve\ A\_SUB,\ B\_MAIN,\ C\_SUP,\ D} ---
tridiagonal direct solve.

\section{\texorpdfstring{\texttt{richardson\_extrapolation}}{richardson\_extrapolation}}\label{richardson_extrapolation}

\texttt{richardson\_extrapolation\ F,\ H0\ {[},\ LEVELS{]}} ---
Romberg-style extrapolation.

\section{\texorpdfstring{\texttt{finite\_difference\_5pt}}{finite\_difference\_5pt}}\label{finite_difference_5pt}

\texttt{finite\_difference\_5pt\ F,\ X\ {[},\ H{]}} --- five-point
central derivative.

\protect\phantomsection\label{ch-crypto-modular-algebra}
\chapter{Crypto / Modular Algebra}\label{crypto-modular-algebra}

5 topics

\section{\texorpdfstring{\texttt{tonelli\_shanks\_sqrt}}{tonelli\_shanks\_sqrt}}\label{tonelli_shanks_sqrt}

\texttt{tonelli\_shanks\_sqrt\ N,\ P} --- modular square root mod prime
p.

\section{\texorpdfstring{\texttt{baby\_step\_giant\_step}}{baby\_step\_giant\_step}}\label{baby_step_giant_step}

\texttt{baby\_step\_giant\_step\ G,\ H,\ P} --- discrete logarithm mod
p.

\section{\texorpdfstring{\texttt{pollard\_rho\_factor}}{pollard\_rho\_factor}}\label{pollard_rho_factor}

\texttt{pollard\_rho\_factor\ N} --- return a non-trivial factor of N.

\section{\texorpdfstring{\texttt{modular\_lcm}}{modular\_lcm}}\label{modular_lcm}

\texttt{modular\_lcm\ XS} --- LCM via gcd.

\section{\texorpdfstring{\texttt{crt\_general}}{crt\_general}}\label{crt_general}

\texttt{crt\_general\ REMAINDERS,\ MODULI} --- CRT over arbitrary (not
coprime) moduli; -1 if infeasible.

\protect\phantomsection\label{ch-physics-chemistry}
\chapter{Physics \& Chemistry}\label{physics-chemistry}

5 topics

\section{\texorpdfstring{\texttt{van\_der\_waals\_p}}{van\_der\_waals\_p}}\label{van_der_waals_p}

\texttt{van\_der\_waals\_p\ N,\ T,\ V,\ A,\ B} --- pressure from Van der
Waals equation.

\section{\texorpdfstring{\texttt{nernst\_equation}}{nernst\_equation}}\label{nernst_equation}

\texttt{nernst\_equation\ E0,\ N,\ T,\ Q} --- half-cell potential.

\section{\texorpdfstring{\texttt{arrhenius\_rate}}{arrhenius\_rate}}\label{arrhenius_rate}

\texttt{arrhenius\_rate\ A,\ EA,\ T} --- k = A exp(-Ea / RT).

\section{\texorpdfstring{\texttt{reduced\_mass}}{reduced\_mass}}\label{reduced_mass}

\texttt{reduced\_mass\ M1,\ M2} --- μ = m1 m2 / (m1 + m2).

\section{\texorpdfstring{\texttt{ph\_to\_concentration}}{ph\_to\_concentration}}\label{ph_to_concentration}

\texttt{ph\_to\_concentration\ PH} --- {[}H⁺{]} = 10\^{}\{-pH\}.

\protect\phantomsection\label{ch-mcmc-sdes}
\chapter{MCMC \& SDEs}\label{mcmc-sdes}

5 topics

\section{\texorpdfstring{\texttt{metropolis\_hastings}}{metropolis\_hastings}}\label{metropolis_hastings}

\texttt{metropolis\_hastings\ LOG\_PI,\ X0,\ SIGMA,\ ITERS\ {[},\ BURN\_IN{]}}
--- random-walk MH.

\section{\texorpdfstring{\texttt{gibbs\_sampler\_step}}{gibbs\_sampler\_step}}\label{gibbs_sampler_step}

\texttt{gibbs\_sampler\_step\ COND\_SAMPLERS,\ X} --- one Gibbs sweep
over coordinates.

\section{\texorpdfstring{\texttt{euler\_maruyama}}{euler\_maruyama}}\label{euler_maruyama}

\texttt{euler\_maruyama\ MU,\ SIGMA,\ X0,\ T0,\ T\_END,\ N\_STEPS} ---
Euler-Maruyama SDE integrator.

\section{\texorpdfstring{\texttt{milstein}}{milstein}}\label{milstein}

\texttt{milstein\ MU,\ SIGMA,\ SIGMA\_X,\ X0,\ T0,\ T\_END,\ N\_STEPS}
--- Milstein scheme.

\section{\texorpdfstring{\texttt{ornstein\_uhlenbeck\_path}}{ornstein\_uhlenbeck\_path}}\label{ornstein_uhlenbeck_path}

\texttt{ornstein\_uhlenbeck\_path\ THETA,\ MU,\ SIGMA,\ X0,\ T,\ N} ---
exact OU sample path.

\protect\phantomsection\label{ch-hidden-markov-models}
\chapter{Hidden Markov Models}\label{hidden-markov-models}

3 topics

\section{\texorpdfstring{\texttt{hmm\_forward}}{hmm\_forward}}\label{hmm_forward}

\texttt{hmm\_forward\ PI,\ A,\ B,\ OBS} --- log P(O \textbar{} λ).

\section{\texorpdfstring{\texttt{hmm\_viterbi}}{hmm\_viterbi}}\label{hmm_viterbi}

\texttt{hmm\_viterbi\ PI,\ A,\ B,\ OBS} --- most-likely state path.

\section{\texorpdfstring{\texttt{hmm\_backward}}{hmm\_backward}}\label{hmm_backward}

\texttt{hmm\_backward\ PI,\ A,\ B,\ OBS} --- backward β matrix.

\protect\phantomsection\label{ch-survival-analysis}
\chapter{Survival Analysis}\label{survival-analysis}

2 topics

\section{\texorpdfstring{\texttt{kaplan\_meier}}{kaplan\_meier}}\label{kaplan_meier}

\texttt{kaplan\_meier\ TIMES,\ EVENTS} → matrix of {[}t, S(t){]}.

\section{\texorpdfstring{\texttt{log\_rank\_test}}{log\_rank\_test}}\label{log_rank_test}

\texttt{log\_rank\_test\ T1,\ E1,\ T2,\ E2} → \texttt{{[}chi²,\ p{]}}.

\protect\phantomsection\label{ch-sequence-alignment}
\chapter{Sequence Alignment}\label{sequence-alignment}

2 topics

\section{\texorpdfstring{\texttt{needleman\_wunsch}}{needleman\_wunsch}}\label{needleman_wunsch}

\texttt{needleman\_wunsch\ A,\ B\ {[},\ MATCH,\ MISMATCH,\ GAP{]}} ---
global alignment score.

\section{\texorpdfstring{\texttt{smith\_waterman}}{smith\_waterman}}\label{smith_waterman}

\texttt{smith\_waterman\ A,\ B\ {[},\ MATCH,\ MISMATCH,\ GAP{]}} ---
best local-alignment score.

\protect\phantomsection\label{ch-chemistry}
\chapter{Chemistry}\label{chemistry}

4 topics

\section{\texorpdfstring{\texttt{gibbs\_free\_energy}}{gibbs\_free\_energy}}\label{gibbs_free_energy}

\texttt{gibbs\_free\_energy\ DH\ {[},\ T,\ DS{]}} --- ΔG = ΔH − TΔS.

\section{\texorpdfstring{\texttt{henderson\_hasselbalch}}{henderson\_hasselbalch}}\label{henderson_hasselbalch}

\texttt{henderson\_hasselbalch\ PKA,\ A\_CONJ,\ HA} --- pH = pKa +
log10({[}A⁻{]}/{[}HA{]}).

\section{\texorpdfstring{\texttt{radioactive\_decay}}{radioactive\_decay}}\label{radioactive_decay}

\texttt{radioactive\_decay\ N0,\ LAMBDA,\ T} --- N(t) = N₀ e\^{}\{-λt\}.

\section{\texorpdfstring{\texttt{half\_life\_to\_constant}}{half\_life\_to\_constant}}\label{half_life_to_constant}

\texttt{half\_life\_to\_constant\ T\_HALF} --- λ = ln 2 / t\_½.

\protect\phantomsection\label{ch-control-theory}
\chapter{Control Theory}\label{control-theory}

5 topics

\section{\texorpdfstring{\texttt{pid\_step}}{pid\_step}}\label{pid_step}

\texttt{pid\_step\ STATE,\ KP,\ KI,\ KD,\ E,\ DT} →
\texttt{{[}new\_state,\ u{]}} (PID controller).

\section{\texorpdfstring{\texttt{transfer\_function\_eval}}{transfer\_function\_eval}}\label{transfer_function_eval}

\texttt{transfer\_function\_eval\ NUM,\ DEN,\ OMEGA} →
\texttt{{[}Re,\ Im{]}} of H(jω).

\section{\texorpdfstring{\texttt{bode\_magnitude\_db}}{bode\_magnitude\_db}}\label{bode_magnitude_db}

\texttt{bode\_magnitude\_db\ NUM,\ DEN,\ OMEGA} --- 20 log₁₀
\textbar H(jω)\textbar.

\section{\texorpdfstring{\texttt{bode\_phase\_deg}}{bode\_phase\_deg}}\label{bode_phase_deg}

\texttt{bode\_phase\_deg\ NUM,\ DEN,\ OMEGA} --- phase of H(jω) in
degrees.

\section{\texorpdfstring{\texttt{lqr\_2x2}}{lqr\_2x2}}\label{lqr_2x2}

\texttt{lqr\_2x2\ A,\ B,\ Q,\ R} --- closed-form 2×2 continuous LQR.
Returns \texttt{{[}K,\ P{]}}.

\protect\phantomsection\label{ch-game-theory}
\chapter{Game Theory}\label{game-theory}

3 topics

\section{\texorpdfstring{\texttt{nash\_eq\_2x2}}{nash\_eq\_2x2}}\label{nash_eq_2x2}

\texttt{nash\_eq\_2x2\ P1,\ P2} --- pure Nash equilibria of a 2×2
bimatrix game.

\section{\texorpdfstring{\texttt{shapley\_value}}{shapley\_value}}\label{shapley_value}

\texttt{shapley\_value\ N,\ V\_TABLE} --- Shapley values from
characteristic-function vector.

\section{\texorpdfstring{\texttt{expected\_utility}}{expected\_utility}}\label{expected_utility}

\texttt{expected\_utility\ PROBS,\ PAYOFFS} --- Σ p·u.

\protect\phantomsection\label{ch-operations-research}
\chapter{Operations Research}\label{operations-research}

3 topics

\section{\texorpdfstring{\texttt{hungarian\_assignment}}{hungarian\_assignment}}\label{hungarian_assignment}

\texttt{hungarian\_assignment\ COST\_MATRIX} --- assignment + total
cost. (Greedy heuristic; reduces to Hungarian for small instances.)

\section{\texorpdfstring{\texttt{tsp\_nearest\_neighbor}}{tsp\_nearest\_neighbor}}\label{tsp_nearest_neighbor}

\texttt{tsp\_nearest\_neighbor\ DIST\_MATRIX} →
\texttt{{[}tour,\ length{]}}.

\section{\texorpdfstring{\texttt{vertex\_cover\_2approx}}{vertex\_cover\_2approx}}\label{vertex_cover_2approx}

\texttt{vertex\_cover\_2approx\ ADJ} --- 2-approximation greedy.

\protect\phantomsection\label{ch-numerical-pde}
\chapter{Numerical PDE}\label{numerical-pde}

3 topics

\section{\texorpdfstring{\texttt{heat\_eq\_1d}}{heat\_eq\_1d}}\label{heat_eq_1d}

\texttt{heat\_eq\_1d\ F,\ A,\ B,\ NX,\ T,\ NT,\ ALPHA} --- explicit FTCS
heat-equation solver.

\section{\texorpdfstring{\texttt{wave\_eq\_1d}}{wave\_eq\_1d}}\label{wave_eq_1d}

\texttt{wave\_eq\_1d\ F,\ A,\ B,\ NX,\ T,\ NT,\ C} --- explicit
wave-equation solver.

\section{\texorpdfstring{\texttt{laplace\_2d\_jacobi}}{laplace\_2d\_jacobi}}\label{laplace_2d_jacobi}

\texttt{laplace\_2d\_jacobi\ GRID\ {[},\ MAX\_ITER,\ TOL{]}} --- Jacobi
smoother on a Dirichlet grid.

\protect\phantomsection\label{ch-bayesian-conjugate-updates}
\chapter{Bayesian Conjugate Updates}\label{bayesian-conjugate-updates}

4 topics

\section{\texorpdfstring{\texttt{beta\_binomial\_update}}{beta\_binomial\_update}}\label{beta_binomial_update}

\texttt{beta\_binomial\_update\ ALPHA,\ BETA,\ N,\ K} → posterior
\texttt{{[}α\textquotesingle{},\ β\textquotesingle{}{]}}.

\section{\texorpdfstring{\texttt{normal\_normal\_update}}{normal\_normal\_update}}\label{normal_normal_update}

\texttt{normal\_normal\_update\ MU0,\ VAR0,\ N,\ YBAR,\ VAR\_DATA} →
\texttt{{[}μ\_post,\ σ²\_post{]}}.

\section{\texorpdfstring{\texttt{gamma\_poisson\_update}}{gamma\_poisson\_update}}\label{gamma_poisson_update}

\texttt{gamma\_poisson\_update\ ALPHA,\ BETA,\ N,\ TOTAL\_EVENTS} →
\texttt{{[}α\textquotesingle{},\ β\textquotesingle{}{]}}.

\section{\texorpdfstring{\texttt{dirichlet\_multinomial\_update}}{dirichlet\_multinomial\_update}}\label{dirichlet_multinomial_update}

\texttt{dirichlet\_multinomial\_update\ ALPHA,\ COUNTS} → α + counts.

\protect\phantomsection\label{ch-quantum-computing-gates}
\chapter{Quantum Computing Gates}\label{quantum-computing-gates}

8 topics

\section{\texorpdfstring{\texttt{hadamard\_gate}}{hadamard\_gate}}\label{hadamard_gate}

\texttt{hadamard\_gate} --- 2×2 Hadamard.

\section{\texorpdfstring{\texttt{cnot\_gate}}{cnot\_gate}}\label{cnot_gate}

\texttt{cnot\_gate} --- 4×4 controlled-NOT.

\section{\texorpdfstring{\texttt{swap\_gate}}{swap\_gate}}\label{swap_gate}

\texttt{swap\_gate} --- 4×4 SWAP.

\section{\texorpdfstring{\texttt{cz\_gate}}{cz\_gate}}\label{cz_gate}

\texttt{cz\_gate} --- 4×4 controlled-Z.

\section{\texorpdfstring{\texttt{qft\_matrix}}{qft\_matrix}}\label{qft_matrix}

\texttt{qft\_matrix\ N} → \texttt{{[}Re,\ Im{]}} of N×N QFT matrix.

\section{\texorpdfstring{\texttt{phase\_gate}}{phase\_gate}}\label{phase_gate}

\texttt{phase\_gate\ PHI} → \texttt{{[}Re,\ Im{]}} of diag(1, e\^{}iφ).

\section{\texorpdfstring{\texttt{s\_gate}}{s\_gate}}\label{s_gate}

\texttt{s\_gate} --- phase(π/2).

\section{\texorpdfstring{\texttt{t\_gate}}{t\_gate}}\label{t_gate}

\texttt{t\_gate} --- phase(π/4).

\protect\phantomsection\label{ch-splines-curves}
\chapter{Splines \& Curves}\label{splines-curves}

4 topics

\section{\texorpdfstring{\texttt{bezier\_eval}}{bezier\_eval}}\label{bezier_eval}

\texttt{bezier\_eval\ CONTROL\_PTS,\ T} --- de Casteljau evaluation.

\section{\texorpdfstring{\texttt{catmull\_rom\_eval}}{catmull\_rom\_eval}}\label{catmull_rom_eval}

\texttt{catmull\_rom\_eval\ P0,\ P1,\ P2,\ P3,\ T} --- uniform
Catmull-Rom.

\section{\texorpdfstring{\texttt{cubic\_hermite\_eval}}{cubic\_hermite\_eval}}\label{cubic_hermite_eval}

\texttt{cubic\_hermite\_eval\ P0,\ M0,\ P1,\ M1,\ T} --- Hermite basis
interpolation.

\section{\texorpdfstring{\texttt{bspline\_basis}}{bspline\_basis}}\label{bspline_basis}

\texttt{bspline\_basis\ I,\ K,\ T,\ KNOTS} --- Cox-de Boor B-spline
basis.

\protect\phantomsection\label{ch-music-audio}
\chapter{Music \& Audio}\label{music-audio}

4 topics

\section{\texorpdfstring{\texttt{freq\_to\_midi}}{freq\_to\_midi}}\label{freq_to_midi}

\texttt{freq\_to\_midi\ F} --- MIDI note number from frequency.

\section{\texorpdfstring{\texttt{midi\_to\_freq}}{midi\_to\_freq}}\label{midi_to_freq}

\texttt{midi\_to\_freq\ M} --- frequency from MIDI note.

\section{\texorpdfstring{\texttt{equal\_temperament\_freq}}{equal\_temperament\_freq}}\label{equal_temperament_freq}

\texttt{equal\_temperament\_freq\ SEMITONES\_ABOVE\_A4} --- 12-TET
frequency.

\section{\texorpdfstring{\texttt{cents\_difference}}{cents\_difference}}\label{cents_difference}

\texttt{cents\_difference\ F1,\ F2} --- 1200 log₂(F2/F1).

\protect\phantomsection\label{ch-astronomy-cosmology}
\chapter{Astronomy \& Cosmology}\label{astronomy-cosmology}

3 topics

\section{\texorpdfstring{\texttt{redshift\_z}}{redshift\_z}}\label{redshift_z}

\texttt{redshift\_z\ LAMBDA\_OBS,\ LAMBDA\_EMIT} --- z = λ\_obs/λ\_emit
− 1.

\section{\texorpdfstring{\texttt{hubble\_distance}}{hubble\_distance}}\label{hubble_distance}

\texttt{hubble\_distance\ H0} --- c / H₀ in Mpc.

\section{\texorpdfstring{\texttt{luminosity\_distance}}{luminosity\_distance}}\label{luminosity_distance}

\texttt{luminosity\_distance\ Z,\ H0,\ OMEGA\_M,\ OMEGA\_L} --- flat
ΛCDM (numeric).

\protect\phantomsection\label{ch-fluid-dynamics}
\chapter{Fluid Dynamics}\label{fluid-dynamics}

4 topics

\section{\texorpdfstring{\texttt{reynolds\_number}}{reynolds\_number}}\label{reynolds_number}

\texttt{reynolds\_number\ RHO,\ U,\ L,\ MU} --- ρ U L / μ.

\section{\texorpdfstring{\texttt{mach\_number}}{mach\_number}}\label{mach_number}

\texttt{mach\_number\ U,\ C} --- U / c.

\section{\texorpdfstring{\texttt{prandtl\_number}}{prandtl\_number}}\label{prandtl_number}

\texttt{prandtl\_number\ CP,\ MU,\ K} --- c\_p μ / k.

\section{\texorpdfstring{\texttt{bernoulli\_velocity}}{bernoulli\_velocity}}\label{bernoulli_velocity}

\texttt{bernoulli\_velocity\ P1,\ P2,\ RHO} --- √(2(p₁ − p₂)/ρ).

\protect\phantomsection\label{ch-distributions-discrete-circular}
\chapter{Distributions (Discrete /
Circular)}\label{distributions-discrete-circular}

4 topics

\section{\texorpdfstring{\texttt{negative\_binomial\_pmf}}{negative\_binomial\_pmf}}\label{negative_binomial_pmf}

\texttt{negative\_binomial\_pmf\ K,\ R,\ P} ---
failures-before-rth-success PMF.

\section{\texorpdfstring{\texttt{hypergeometric\_pmf}}{hypergeometric\_pmf}}\label{hypergeometric_pmf}

\texttt{hypergeometric\_pmf\ N,\ K\_POP,\ N\_DRAWS,\ K\_OBS} ---
finite-population PMF.

\section{\texorpdfstring{\texttt{beta\_binomial\_pmf}}{beta\_binomial\_pmf}}\label{beta_binomial_pmf}

\texttt{beta\_binomial\_pmf\ K,\ N,\ ALPHA,\ BETA} --- beta-binomial
PMF.

\section{\texorpdfstring{\texttt{von\_mises\_pdf}}{von\_mises\_pdf}}\label{von_mises_pdf}

\texttt{von\_mises\_pdf\ THETA,\ MU,\ KAPPA} --- circular Gaussian.

\protect\phantomsection\label{ch-random-graph-generators}
\chapter{Random Graph Generators}\label{random-graph-generators}

3 topics

\section{\texorpdfstring{\texttt{erdos\_renyi\_random}}{erdos\_renyi\_random}}\label{erdos_renyi_random}

\texttt{erdos\_renyi\_random\ N,\ P} --- G(n, p) Bernoulli edge model.

\section{\texorpdfstring{\texttt{barabasi\_albert\_random}}{barabasi\_albert\_random}}\label{barabasi_albert_random}

\texttt{barabasi\_albert\_random\ N,\ M} --- preferential-attachment
model.

\section{\texorpdfstring{\texttt{watts\_strogatz\_random}}{watts\_strogatz\_random}}\label{watts_strogatz_random}

\texttt{watts\_strogatz\_random\ N,\ K,\ P} --- small-world rewiring.

\protect\phantomsection\label{ch-color-science}
\chapter{Color Science}\label{color-science}

3 topics

\section{\texorpdfstring{\texttt{rgb\_to\_lab}}{rgb\_to\_lab}}\label{rgb_to_lab}

\texttt{rgb\_to\_lab\ R,\ G,\ B} --- sRGB → CIE Lab.

\section{\texorpdfstring{\texttt{lab\_to\_rgb}}{lab\_to\_rgb}}\label{lab_to_rgb}

\texttt{lab\_to\_rgb\ L,\ A,\ B} --- CIE Lab → sRGB.

\section{\texorpdfstring{\texttt{kelvin\_to\_rgb}}{kelvin\_to\_rgb}}\label{kelvin_to_rgb}

\texttt{kelvin\_to\_rgb\ K} --- black-body sRGB approximation (Tanner
Helland).

\protect\phantomsection\label{ch-integer-sequences-combinatorial}
\chapter{Integer Sequences
(Combinatorial)}\label{integer-sequences-combinatorial}

4 topics

\section{\texorpdfstring{\texttt{bell\_triangle}}{bell\_triangle}}\label{bell_triangle}

\texttt{bell\_triangle\ N} --- first N+1 rows of the Bell / Aitken
triangle.

\section{\texorpdfstring{\texttt{surjection\_count}}{surjection\_count}}\label{surjection_count}

\texttt{surjection\_count\ N,\ K} --- k! · S(n, k).

\section{\texorpdfstring{\texttt{distinct\_partition\_count}}{distinct\_partition\_count}}\label{distinct_partition_count}

\texttt{distinct\_partition\_count\ N} --- partitions of N into distinct
parts.

\section{\texorpdfstring{\texttt{fibonacci\_q}}{fibonacci\_q}}\label{fibonacci_q}

\texttt{fibonacci\_q\ N} --- 1 if N is a Fibonacci number.

\protect\phantomsection\label{ch-multiple-testing-corrections}
\chapter{Multiple-Testing
Corrections}\label{multiple-testing-corrections}

3 topics

\section{\texorpdfstring{\texttt{bonferroni\_correction}}{bonferroni\_correction}}\label{bonferroni_correction}

\texttt{bonferroni\_correction\ PVALS} --- Bonferroni-adjusted p-values
(capped at 1).

\section{\texorpdfstring{\texttt{benjamini\_hochberg}}{benjamini\_hochberg}}\label{benjamini_hochberg}

\texttt{benjamini\_hochberg\ PVALS} --- BH FDR q-values.

\section{\texorpdfstring{\texttt{tukey\_hsd}}{tukey\_hsd}}\label{tukey_hsd}

\texttt{tukey\_hsd\ ALPHA,\ K,\ DF,\ MSE,\ N} --- Tukey
honestly-significant-difference critical bound.

\protect\phantomsection\label{ch-probabilistic-distances}
\chapter{Probabilistic Distances}\label{probabilistic-distances}

3 topics

\section{\texorpdfstring{\texttt{hellinger\_distance}}{hellinger\_distance}}\label{hellinger_distance}

\texttt{hellinger\_distance\ P,\ Q} --- √(½ Σ (√p − √q)²).

\section{\texorpdfstring{\texttt{wasserstein\_1d}}{wasserstein\_1d}}\label{wasserstein_1d}

\texttt{wasserstein\_1d\ A,\ B} --- earth-mover distance for sorted
samples.

\section{\texorpdfstring{\texttt{chi\_squared\_divergence}}{chi\_squared\_divergence}}\label{chi_squared_divergence}

\texttt{chi\_squared\_divergence\ P,\ Q} --- Σ (p − q)² / q.

\protect\phantomsection\label{ch-distributions-tail-inflated}
\chapter{Distributions (Tail /
Inflated)}\label{distributions-tail-inflated}

3 topics

\section{\texorpdfstring{\texttt{beta\_geometric\_pmf}}{beta\_geometric\_pmf}}\label{beta_geometric_pmf}

\texttt{beta\_geometric\_pmf\ K,\ ALPHA,\ BETA} --- beta-geometric PMF.

\section{\texorpdfstring{\texttt{generalized\_gamma\_pdf}}{generalized\_gamma\_pdf}}\label{generalized_gamma_pdf}

\texttt{generalized\_gamma\_pdf\ X,\ A,\ D,\ P} --- generalised-gamma
PDF.

\section{\texorpdfstring{\texttt{zip\_pmf}}{zip\_pmf}}\label{zip_pmf}

\texttt{zip\_pmf\ K,\ PI,\ LAMBDA} --- zero-inflated Poisson.

\protect\phantomsection\label{ch-astrophysics-radiation}
\chapter{Astrophysics \& Radiation}\label{astrophysics-radiation}

9 topics

\section{\texorpdfstring{\texttt{stefan\_boltzmann\_luminosity}}{stefan\_boltzmann\_luminosity}}\label{stefan_boltzmann_luminosity}

\texttt{stefan\_boltzmann\_luminosity\ R,\ T} --- L = 4π R² σ T⁴.

\section{\texorpdfstring{\texttt{photon\_momentum}}{photon\_momentum}}\label{photon_momentum}

\texttt{photon\_momentum\ LAMBDA} --- h / λ.

\section{\texorpdfstring{\texttt{photon\_energy\_ev}}{photon\_energy\_ev}}\label{photon_energy_ev}

\texttt{photon\_energy\_ev\ LAMBDA} --- hc / λ in eV.

\section{\texorpdfstring{\texttt{dipole\_radiation\_power}}{dipole\_radiation\_power}}\label{dipole_radiation_power}

\texttt{dipole\_radiation\_power\ Q,\ A} --- Larmor formula.

\section{\texorpdfstring{\texttt{parallax\_to\_distance}}{parallax\_to\_distance}}\label{parallax_to_distance}

\texttt{parallax\_to\_distance\ P\_ARCSEC} --- parsecs from arcseconds.

\section{\texorpdfstring{\texttt{hawking\_temperature}}{hawking\_temperature}}\label{hawking_temperature}

\texttt{hawking\_temperature\ M\_KG} --- black-hole temperature.

\section{\texorpdfstring{\texttt{roche\_limit}}{roche\_limit}}\label{roche_limit}

\texttt{roche\_limit\ R,\ RHO\_PRIMARY,\ RHO\_SAT} --- rigid-body Roche
limit.

\section{\texorpdfstring{\texttt{apparent\_magnitude}}{apparent\_magnitude}}\label{apparent_magnitude}

\texttt{apparent\_magnitude\ ABS\_M,\ D\_PC} --- m = M + 5 log₁₀(d/10).

\section{\texorpdfstring{\texttt{distance\_modulus}}{distance\_modulus}}\label{distance_modulus}

\texttt{distance\_modulus\ D\_PC} --- μ = 5 log d − 5.

\protect\phantomsection\label{ch-chemistry-beer-rate-colligative}
\chapter{Chemistry (Beer / Rate /
Colligative)}\label{chemistry-beer-rate-colligative}

3 topics

\section{\texorpdfstring{\texttt{beer\_lambert}}{beer\_lambert}}\label{beer_lambert}

\texttt{beer\_lambert\ EPSILON,\ L,\ C} --- A = ε·l·c.

\section{\texorpdfstring{\texttt{rate\_law\_n}}{rate\_law\_n}}\label{rate_law_n}

\texttt{rate\_law\_n\ A0,\ K,\ T,\ N} --- concentration after time t for
nth-order reaction.

\section{\texorpdfstring{\texttt{freezing\_point\_depression}}{freezing\_point\_depression}}\label{freezing_point_depression}

\texttt{freezing\_point\_depression\ KF,\ MOLALITY,\ I} --- ΔT = K\_f m
i.

\protect\phantomsection\label{ch-mixed-strategy-game-theory}
\chapter{Mixed-Strategy Game Theory}\label{mixed-strategy-game-theory}

2 topics

\section{\texorpdfstring{\texttt{mixed\_nash\_2x2}}{mixed\_nash\_2x2}}\label{mixed_nash_2x2}

\texttt{mixed\_nash\_2x2\ P1,\ P2} → \texttt{{[}p,\ q{]}} mixed-strategy
probabilities.

\section{\texorpdfstring{\texttt{minimax\_2x2}}{minimax\_2x2}}\label{minimax_2x2}

\texttt{minimax\_2x2\ M} --- security level for the row player.

\protect\phantomsection\label{ch-computer-graphics}
\chapter{Computer Graphics}\label{computer-graphics}

4 topics

\section{\texorpdfstring{\texttt{barycentric\_coords\_2d}}{barycentric\_coords\_2d}}\label{barycentric_coords_2d}

\texttt{barycentric\_coords\_2d\ P,\ A,\ B,\ C} →
\texttt{{[}u,\ v,\ w{]}}.

\section{\texorpdfstring{\texttt{bresenham\_line}}{bresenham\_line}}\label{bresenham_line}

\texttt{bresenham\_line\ X0,\ Y0,\ X1,\ Y1} → array of integer pixels.

\section{\texorpdfstring{\texttt{bilinear\_interp\_2d}}{bilinear\_interp\_2d}}\label{bilinear_interp_2d}

\texttt{bilinear\_interp\_2d\ F00,\ F10,\ F01,\ F11,\ U,\ V} ---
unit-square bilinear.

\section{\texorpdfstring{\texttt{point\_in\_polygon\_2d}}{point\_in\_polygon\_2d}}\label{point_in_polygon_2d}

\texttt{point\_in\_polygon\_2d\ P,\ POLY} --- ray-casting test.

\protect\phantomsection\label{ch-dsp-hilbert-cepstrum-filter-design}
\chapter{DSP (Hilbert / Cepstrum / Filter
Design)}\label{dsp-hilbert-cepstrum-filter-design}

5 topics

\section{\texorpdfstring{\texttt{hilbert\_transform}}{hilbert\_transform}}\label{hilbert_transform}

\texttt{hilbert\_transform\ XS} --- discrete Hilbert via DFT.

\section{\texorpdfstring{\texttt{cepstrum}}{cepstrum}}\label{cepstrum}

\texttt{cepstrum\ XS} --- real cepstrum ifft(log\textbar fft\textbar).

\section{\texorpdfstring{\texttt{butterworth\_lowpass\_coeffs}}{butterworth\_lowpass\_coeffs}}\label{butterworth_lowpass_coeffs}

\texttt{butterworth\_lowpass\_coeffs\ ORDER,\ CUTOFF} →
\texttt{{[}b,\ a{]}} digital biquad-cascade.

\section{\texorpdfstring{\texttt{savitzky\_golay\_coeffs}}{savitzky\_golay\_coeffs}}\label{savitzky_golay_coeffs}

\texttt{savitzky\_golay\_coeffs\ NL,\ NR,\ M} --- SG filter
coefficients.

\section{\texorpdfstring{\texttt{savitzky\_golay\_filter}}{savitzky\_golay\_filter}}\label{savitzky_golay_filter}

\texttt{savitzky\_golay\_filter\ XS,\ COEFFS} --- apply pre-computed SG
coefficients.

\protect\phantomsection\label{ch-image-processing-edges-bilateral}
\chapter{Image Processing (Edges /
Bilateral)}\label{image-processing-edges-bilateral}

2 topics

\section{\texorpdfstring{\texttt{canny\_edge\_intensity}}{canny\_edge\_intensity}}\label{canny_edge_intensity}

\texttt{canny\_edge\_intensity\ IMG} --- Sobel-magnitude edge map
(caller thresholds).

\section{\texorpdfstring{\texttt{bilateral\_filter\_basic}}{bilateral\_filter\_basic}}\label{bilateral_filter_basic}

\texttt{bilateral\_filter\_basic\ IMG,\ RADIUS,\ SIGMA\_S,\ SIGMA\_R}
--- edge-preserving smoother.

\protect\phantomsection\label{ch-clustering-helpers}
\chapter{Clustering Helpers}\label{clustering-helpers}

2 topics

\section{\texorpdfstring{\texttt{kmeans\_pp\_init}}{kmeans\_pp\_init}}\label{kmeans_pp_init}

\texttt{kmeans\_pp\_init\ POINTS,\ K} --- k-means++ seed centroids.

\section{\texorpdfstring{\texttt{elbow\_score}}{elbow\_score}}\label{elbow_score}

\texttt{elbow\_score\ POINTS,\ LABELS} --- within-cluster sum of
squares.

\protect\phantomsection\label{ch-combinatorics-tableaux-boustrophedon}
\chapter{Combinatorics (Tableaux /
Boustrophedon)}\label{combinatorics-tableaux-boustrophedon}

4 topics

\section{\texorpdfstring{\texttt{young\_tableaux\_count}}{young\_tableaux\_count}}\label{young_tableaux_count}

\texttt{young\_tableaux\_count\ LAMBDA} --- hook-length formula.

\section{\texorpdfstring{\texttt{euler\_alt\_permutation}}{euler\_alt\_permutation}}\label{euler_alt_permutation}

\texttt{euler\_alt\_permutation\ N} --- Euler / zigzag number A000111.

\section{\texorpdfstring{\texttt{genocchi\_number}}{genocchi\_number}}\label{genocchi_number}

\texttt{genocchi\_number\ N} --- G\_n via Bernoulli identity.

\section{\texorpdfstring{\texttt{lattice\_paths\_count}}{lattice\_paths\_count}}\label{lattice_paths_count}

\texttt{lattice\_paths\_count\ M,\ N} --- C(m+n, n) east/north paths.

\protect\phantomsection\label{ch-number-theory-tetration-smoothness}
\chapter{Number Theory (Tetration /
Smoothness)}\label{number-theory-tetration-smoothness}

4 topics

\section{\texorpdfstring{\texttt{tetration}}{tetration}}\label{tetration}

\texttt{tetration\ A,\ N} --- N-fold a-tower (overflow → ∞).

\section{\texorpdfstring{\texttt{ackermann\_limited}}{ackermann\_limited}}\label{ackermann_limited}

\texttt{ackermann\_limited\ M,\ N} --- depth-limited Ackermann (refuses
past M=3 N=14).

\section{\texorpdfstring{\texttt{perfect\_power\_q}}{perfect\_power\_q}}\label{perfect_power_q}

\texttt{perfect\_power\_q\ N} --- 1 if N = a\^{}b for integers a, b ≥ 2.

\section{\texorpdfstring{\texttt{b\_smooth\_q}}{b\_smooth\_q}}\label{b_smooth_q}

\texttt{b\_smooth\_q\ N,\ B} --- 1 if every prime factor of N is ≤ B.

\protect\phantomsection\label{ch-network-coreness-structure}
\chapter{Network Coreness \&
Structure}\label{network-coreness-structure}

2 topics

\section{\texorpdfstring{\texttt{k\_core}}{k\_core}}\label{k_core}

\texttt{k\_core\ ADJ} --- vertex coreness.

\section{\texorpdfstring{\texttt{rich\_club\_coefficient}}{rich\_club\_coefficient}}\label{rich_club_coefficient}

\texttt{rich\_club\_coefficient\ ADJ,\ K} --- fraction of edges among
nodes with deg \textgreater{} k.

\protect\phantomsection\label{ch-crypto-helpers}
\chapter{Crypto Helpers}\label{crypto-helpers}

3 topics

\section{\texorpdfstring{\texttt{rsa\_basic\_encrypt}}{rsa\_basic\_encrypt}}\label{rsa_basic_encrypt}

\texttt{rsa\_basic\_encrypt\ M,\ E,\ N} --- m\^{}e mod n.

\section{\texorpdfstring{\texttt{rsa\_basic\_decrypt}}{rsa\_basic\_decrypt}}\label{rsa_basic_decrypt}

\texttt{rsa\_basic\_decrypt\ C,\ D,\ N} --- c\^{}d mod n.

\section{\texorpdfstring{\texttt{dh\_shared\_secret}}{dh\_shared\_secret}}\label{dh_shared_secret}

\texttt{dh\_shared\_secret\ PEER\_PUB,\ PRIVATE,\ P} --- Diffie-Hellman.

\protect\phantomsection\label{ch-quantum-entanglement}
\chapter{Quantum Entanglement}\label{quantum-entanglement}

4 topics

\section{\texorpdfstring{\texttt{bell\_state\_phi\_plus}}{bell\_state\_phi\_plus}}\label{bell_state_phi_plus}

\texttt{bell\_state\_phi\_plus} --- Bell state
(\textbar00⟩+\textbar11⟩)/√2.

\section{\texorpdfstring{\texttt{bell\_state\_psi\_minus}}{bell\_state\_psi\_minus}}\label{bell_state_psi_minus}

\texttt{bell\_state\_psi\_minus} --- singlet
(\textbar01⟩-\textbar10⟩)/√2.

\section{\texorpdfstring{\texttt{density\_matrix\_purity}}{density\_matrix\_purity}}\label{density_matrix_purity}

\texttt{density\_matrix\_purity\ RHO} --- tr(ρ²).

\section{\texorpdfstring{\texttt{concurrence\_2qubit}}{concurrence\_2qubit}}\label{concurrence_2qubit}

\texttt{concurrence\_2qubit\ PSI} --- 2\textbar ad − bc\textbar{} in
real basis.

\protect\phantomsection\label{ch-2-d-geometry-polygons-circles}
\chapter{2-D Geometry (Polygons \&
Circles)}\label{d-geometry-polygons-circles}

4 topics

\section{\texorpdfstring{\texttt{point\_in\_circle}}{point\_in\_circle}}\label{point_in_circle}

\texttt{point\_in\_circle\ P,\ CENTER,\ R} --- 1 if inside.

\section{\texorpdfstring{\texttt{circle\_circle\_intersect\_2d}}{circle\_circle\_intersect\_2d}}\label{circle_circle_intersect_2d}

\texttt{circle\_circle\_intersect\_2d\ C1,\ R1,\ C2,\ R2} --- 0/1/2
intersection points.

\section{\texorpdfstring{\texttt{polygon\_centroid}}{polygon\_centroid}}\label{polygon_centroid}

\texttt{polygon\_centroid\ POLY} --- area-weighted centroid.

\section{\texorpdfstring{\texttt{sutherland\_hodgman\_clip}}{sutherland\_hodgman\_clip}}\label{sutherland_hodgman_clip}

\texttt{sutherland\_hodgman\_clip\ SUBJECT,\ CLIP} --- clip against
convex CCW polygon.

\protect\phantomsection\label{ch-time-series-smoothing}
\chapter{Time-Series Smoothing}\label{time-series-smoothing}

1 topics

\section{\texorpdfstring{\texttt{kalman\_rts\_smoother}}{kalman\_rts\_smoother}}\label{kalman_rts_smoother}

\texttt{kalman\_rts\_smoother\ X\_HAT,\ P,\ X\_PRED,\ P\_PRED,\ F} ---
RTS smoothed means.

\protect\phantomsection\label{ch-bioinformatics}
\chapter{Bioinformatics}\label{bioinformatics}

6 topics

\section{\texorpdfstring{\texttt{gc\_content}}{gc\_content}}\label{gc_content}

\texttt{gc\_content\ SEQ} --- fraction of G + C in DNA / RNA string.

\section{\texorpdfstring{\texttt{codon\_to\_aa}}{codon\_to\_aa}}\label{codon_to_aa}

\texttt{codon\_to\_aa\ CODON} --- single-letter amino-acid (or
\textquotesingle*\textquotesingle{} /
\textquotesingle X\textquotesingle).

\section{\texorpdfstring{\texttt{reverse\_complement\_dna}}{reverse\_complement\_dna}}\label{reverse_complement_dna}

\texttt{reverse\_complement\_dna\ SEQ} --- DNA reverse complement.

\section{\texorpdfstring{\texttt{hamming\_dna}}{hamming\_dna}}\label{hamming_dna}

\texttt{hamming\_dna\ A,\ B} --- case-insensitive Hamming distance.

\section{\texorpdfstring{\texttt{blosum62\_pair\_score}}{blosum62\_pair\_score}}\label{blosum62_pair_score}

\texttt{blosum62\_pair\_score\ A,\ B} --- BLOSUM62 substitution score.

\section{\texorpdfstring{\texttt{kmer\_count}}{kmer\_count}}\label{kmer_count}

\texttt{kmer\_count\ SEQ,\ K} --- total count of length-K windows.

\protect\phantomsection\label{ch-geographic-map-projection}
\chapter{Geographic / Map Projection}\label{geographic-map-projection}

4 topics

\section{\texorpdfstring{\texttt{great\_circle\_bearing}}{great\_circle\_bearing}}\label{great_circle_bearing}

\texttt{great\_circle\_bearing\ LAT1,\ LON1,\ LAT2,\ LON2} --- initial
bearing in degrees.

\section{\texorpdfstring{\texttt{midpoint\_lat\_lon}}{midpoint\_lat\_lon}}\label{midpoint_lat_lon}

\texttt{midpoint\_lat\_lon\ LAT1,\ LON1,\ LAT2,\ LON2} --- great-circle
midpoint.

\section{\texorpdfstring{\texttt{utm\_zone\_for}}{utm\_zone\_for}}\label{utm_zone_for}

\texttt{utm\_zone\_for\ LON} --- UTM zone (1..60).

\section{\texorpdfstring{\texttt{area\_polygon\_lat\_lon}}{area\_polygon\_lat\_lon}}\label{area_polygon_lat_lon}

\texttt{area\_polygon\_lat\_lon\ POLY\ {[},\ R{]}} --- spherical-excess
polygon area in m².

\protect\phantomsection\label{ch-fixed-income-finance}
\chapter{Fixed-Income Finance}\label{fixed-income-finance}

5 topics

\section{\texorpdfstring{\texttt{crr\_binomial\_option}}{crr\_binomial\_option}}\label{crr_binomial_option}

\texttt{crr\_binomial\_option\ S0,\ K,\ T,\ R,\ SIGMA,\ N,\ IS\_PUT} ---
Cox-Ross-Rubinstein price.

\section{\texorpdfstring{\texttt{bond\_price\_clean}}{bond\_price\_clean}}\label{bond_price_clean}

\texttt{bond\_price\_clean\ FACE,\ COUPON,\ N,\ PP\_Y,\ YIELD} ---
present value.

\section{\texorpdfstring{\texttt{bond\_yield\_to\_maturity}}{bond\_yield\_to\_maturity}}\label{bond_yield_to_maturity}

\texttt{bond\_yield\_to\_maturity\ PRICE,\ FACE,\ COUPON,\ N,\ PP\_Y}
--- solve YTM by bisection.

\section{\texorpdfstring{\texttt{modified\_duration\_bond}}{modified\_duration\_bond}}\label{modified_duration_bond}

\texttt{modified\_duration\_bond\ FACE,\ COUPON,\ N,\ PP\_Y,\ YIELD} ---
modified duration.

\section{\texorpdfstring{\texttt{convexity\_bond}}{convexity\_bond}}\label{convexity_bond}

\texttt{convexity\_bond\ FACE,\ COUPON,\ N,\ PP\_Y,\ YIELD} --- bond
convexity measure.

\protect\phantomsection\label{ch-image-quality-metrics}
\chapter{Image Quality Metrics}\label{image-quality-metrics}

3 topics

\section{\texorpdfstring{\texttt{ssim}}{ssim}}\label{ssim}

\texttt{ssim\ A,\ B\ {[},\ L{]}} --- Structural Similarity Index (single
window).

\section{\texorpdfstring{\texttt{psnr}}{psnr}}\label{psnr}

\texttt{psnr\ A,\ B\ {[},\ MAX\_VAL{]}} --- peak SNR in dB.

\section{\texorpdfstring{\texttt{mssim}}{mssim}}\label{mssim}

\texttt{mssim\ A,\ B\ {[},\ WIN,\ L{]}} --- mean SSIM across
non-overlapping windows.

\protect\phantomsection\label{ch-acoustics}
\chapter{Acoustics}\label{acoustics}

4 topics

\section{\texorpdfstring{\texttt{db\_spl\_from\_pa}}{db\_spl\_from\_pa}}\label{db_spl_from_pa}

\texttt{db\_spl\_from\_pa\ P\_PA} --- sound pressure level dB SPL.

\section{\texorpdfstring{\texttt{a\_weighting\_factor}}{a\_weighting\_factor}}\label{a_weighting_factor}

\texttt{a\_weighting\_factor\ F\_HZ} --- IEC 61672 A-weighting
amplitude.

\section{\texorpdfstring{\texttt{octave\_band\_center}}{octave\_band\_center}}\label{octave_band_center}

\texttt{octave\_band\_center\ BAND} --- 1 kHz · 2\^{}band centre
frequency.

\section{\texorpdfstring{\texttt{semitone\_ratio}}{semitone\_ratio}}\label{semitone_ratio}

\texttt{semitone\_ratio} --- 12-TET ratio 2\^{}(1/12).

\protect\phantomsection\label{ch-population-genetics}
\chapter{Population Genetics}\label{population-genetics}

4 topics

\section{\texorpdfstring{\texttt{hardy\_weinberg}}{hardy\_weinberg}}\label{hardy_weinberg}

\texttt{hardy\_weinberg\ P} --- (p², 2pq, q²) genotype frequencies.

\section{\texorpdfstring{\texttt{expected\_heterozygosity}}{expected\_heterozygosity}}\label{expected_heterozygosity}

\texttt{expected\_heterozygosity\ P\_VEC} --- 1 − Σ p\_i².

\section{\texorpdfstring{\texttt{fst\_simple}}{fst\_simple}}\label{fst_simple}

\texttt{fst\_simple\ P1,\ P2,\ N1,\ N2} --- Wright\textquotesingle s
F\_ST between two populations.

\section{\texorpdfstring{\texttt{allele\_frequencies}}{allele\_frequencies}}\label{allele_frequencies}

\texttt{allele\_frequencies\ GENOTYPES} --- p, q from 0/1/2 genotype
counts.

\protect\phantomsection\label{ch-epidemiology}
\chapter{Epidemiology}\label{epidemiology}

3 topics

\section{\texorpdfstring{\texttt{sir\_step}}{sir\_step}}\label{sir_step}

\texttt{sir\_step\ S,\ I,\ R,\ BETA,\ GAMMA,\ DT} --- Euler step of the
SIR model.

\section{\texorpdfstring{\texttt{sir\_r0}}{sir\_r0}}\label{sir_r0}

\texttt{sir\_r0\ BETA,\ GAMMA} --- basic reproduction number β/γ.

\section{\texorpdfstring{\texttt{doubling\_time}}{doubling\_time}}\label{doubling_time}

\texttt{doubling\_time\ R} --- t₂ = ln 2 / r.

\protect\phantomsection\label{ch-inequality-measures}
\chapter{Inequality Measures}\label{inequality-measures}

4 topics

\section{\texorpdfstring{\texttt{theil\_index}}{theil\_index}}\label{theil_index}

\texttt{theil\_index\ XS} --- Theil T inequality index.

\section{\texorpdfstring{\texttt{herfindahl\_hirschman}}{herfindahl\_hirschman}}\label{herfindahl_hirschman}

\texttt{herfindahl\_hirschman\ SHARES} --- Σ s\_i².

\section{\texorpdfstring{\texttt{atkinson\_index}}{atkinson\_index}}\label{atkinson_index}

\texttt{atkinson\_index\ XS\ {[},\ EPS{]}} --- Atkinson inequality with
parameter ε.

\section{\texorpdfstring{\texttt{lorenz\_curve\_points}}{lorenz\_curve\_points}}\label{lorenz_curve_points}

\texttt{lorenz\_curve\_points\ XS} --- matrix of {[}cumulative-pop,
cumulative-income{]}.

\protect\phantomsection\label{ch-apl-j-array-primitives}
\chapter{APL / J Array Primitives}\label{apl-j-array-primitives}

4 topics

\section{\texorpdfstring{\texttt{iota\_range}}{iota\_range}}\label{iota_range}

\texttt{iota\_range\ N} --- \texttt{0..N} (APL convention).

\section{\texorpdfstring{\texttt{reshape\_array}}{reshape\_array}}\label{reshape_array}

\texttt{reshape\_array\ ROWS,\ COLS,\ FLAT} --- APL reshape (cycles
input).

\section{\texorpdfstring{\texttt{grade\_up}}{grade\_up}}\label{grade_up}

\texttt{grade\_up\ XS} --- index permutation that sorts ascending.

\section{\texorpdfstring{\texttt{grade\_down}}{grade\_down}}\label{grade_down}

\texttt{grade\_down\ XS} --- index permutation that sorts descending.

\protect\phantomsection\label{ch-plasma-physics}
\chapter{Plasma Physics}\label{plasma-physics}

4 topics

\section{\texorpdfstring{\texttt{plasma\_frequency}}{plasma\_frequency}}\label{plasma_frequency}

\texttt{plasma\_frequency\ N\_E} --- electron plasma angular frequency
(rad/s).

\section{\texorpdfstring{\texttt{debye\_length}}{debye\_length}}\label{debye_length}

\texttt{debye\_length\ T\_K,\ N\_E} --- Debye screening length.

\section{\texorpdfstring{\texttt{cyclotron\_frequency}}{cyclotron\_frequency}}\label{cyclotron_frequency}

\texttt{cyclotron\_frequency\ B\ {[},\ Q,\ M{]}} --- qB/m (electron
defaults).

\section{\texorpdfstring{\texttt{larmor\_radius}}{larmor\_radius}}\label{larmor_radius}

\texttt{larmor\_radius\ V\_PERP,\ B\ {[},\ Q,\ M{]}} --- gyroradius
(electron defaults).

\protect\phantomsection\label{ch-string-similarity}
\chapter{String Similarity}\label{string-similarity}

2 topics

\section{\texorpdfstring{\texttt{jaro\_winkler\_similarity}}{jaro\_winkler\_similarity}}\label{jaro_winkler_similarity}

\texttt{jaro\_winkler\_similarity\ A,\ B} --- JW string similarity.

\section{\texorpdfstring{\texttt{metaphone\_simple}}{metaphone\_simple}}\label{metaphone_simple}

\texttt{metaphone\_simple\ S} --- abridged Metaphone consonant skeleton.

\protect\phantomsection\label{ch-rating-systems}
\chapter{Rating Systems}\label{rating-systems}

3 topics

\section{\texorpdfstring{\texttt{elo\_rating\_update}}{elo\_rating\_update}}\label{elo_rating_update}

\texttt{elo\_rating\_update\ R\_A,\ R\_B,\ SCORE\_A\ {[},\ K{]}} →
{[}R\_A\textquotesingle, R\_B\textquotesingle{]}.

\section{\texorpdfstring{\texttt{glicko\_rating\_update}}{glicko\_rating\_update}}\label{glicko_rating_update}

\texttt{glicko\_rating\_update\ R,\ RD,\ OPP\_R,\ OPP\_RD,\ SCORE} →
{[}R\textquotesingle, RD\textquotesingle{]}.

\section{\texorpdfstring{\texttt{dice\_sum\_pmf}}{dice\_sum\_pmf}}\label{dice_sum_pmf}

\texttt{dice\_sum\_pmf\ N,\ S,\ TARGET} --- probability of N s-sided
dice summing to TARGET.

\protect\phantomsection\label{ch-effect-sizes}
\chapter{Effect Sizes}\label{effect-sizes}

3 topics

\section{\texorpdfstring{\texttt{cohens\_d}}{cohens\_d}}\label{cohens_d}

\texttt{cohens\_d\ A,\ B} --- pooled-SD standardised mean difference.

\section{\texorpdfstring{\texttt{cliff\_delta}}{cliff\_delta}}\label{cliff_delta}

\texttt{cliff\_delta\ A,\ B} --- non-parametric effect size in {[}-1,
1{]}.

\section{\texorpdfstring{\texttt{vargha\_delaney\_a12}}{vargha\_delaney\_a12}}\label{vargha_delaney_a12}

\texttt{vargha\_delaney\_a12\ A,\ B} --- P(X \textgreater{} Y) + 0.5 P(X
= Y).

\protect\phantomsection\label{ch-control-transient-response}
\chapter{Control Transient Response}\label{control-transient-response}

2 topics

\section{\texorpdfstring{\texttt{step\_response\_2nd\_order}}{step\_response\_2nd\_order}}\label{step_response_2nd_order}

\texttt{step\_response\_2nd\_order\ ZETA,\ OMEGA\_N,\ T} --- y(t).

\section{\texorpdfstring{\texttt{overshoot\_2nd\_order}}{overshoot\_2nd\_order}}\label{overshoot_2nd_order}

\texttt{overshoot\_2nd\_order\ ZETA} --- peak overshoot \%.

\protect\phantomsection\label{ch-matrix-norms}
\chapter{Matrix Norms}\label{matrix-norms}

3 topics

\section{\texorpdfstring{\texttt{frobenius\_norm}}{frobenius\_norm}}\label{frobenius_norm}

\texttt{frobenius\_norm\ M} --- √(Σ m\_ij²).

\section{\texorpdfstring{\texttt{spectral\_norm}}{spectral\_norm}}\label{spectral_norm}

\texttt{spectral\_norm\ M} --- largest singular value.

\section{\texorpdfstring{\texttt{trace\_matrix}}{trace\_matrix}}\label{trace_matrix}

\texttt{trace\_matrix\ M} --- Σ m\_ii.

\protect\phantomsection\label{ch-network-triad-analysis}
\chapter{Network Triad Analysis}\label{network-triad-analysis}

3 topics

\section{\texorpdfstring{\texttt{homophily\_index}}{homophily\_index}}\label{homophily_index}

\texttt{homophily\_index\ ADJ,\ LABELS} --- fraction of same-group
edges.

\section{\texorpdfstring{\texttt{dyad\_census}}{dyad\_census}}\label{dyad_census}

\texttt{dyad\_census\ ADJ} --- {[}mutual, asymmetric, null{]} dyads.

\section{\texorpdfstring{\texttt{triad\_census}}{triad\_census}}\label{triad_census}

\texttt{triad\_census\ ADJ} --- {[}empty, edge, path, triangle{]}
counts.

\protect\phantomsection\label{ch-misc-inverses}
\chapter{Misc Inverses}\label{misc-inverses}

1 topics

\section{\texorpdfstring{\texttt{sigmoid\_inverse}}{sigmoid\_inverse}}\label{sigmoid_inverse}

\texttt{sigmoid\_inverse\ X} --- ln(x / (1-x)).

\protect\phantomsection\label{ch-parallel-i-o}
\chapter{Parallel I/O}\label{parallel-io}

8 topics

\section{\texorpdfstring{\texttt{par\_lines}}{par\_lines}}\label{par_lines}

\texttt{par\_lines\ PATH,\ \{\ code\ \}} --- memory-map a file and scan
its lines in parallel across all available CPU cores.

The file is \texttt{mmap}\textquotesingle d into memory rather than read
sequentially, and line boundaries are detected in parallel chunks. Each
line is passed to the callback as \texttt{\_}. Because the file is
memory-mapped, there is no read-buffer overhead and the OS kernel pages
data in on demand, making \texttt{par\_lines} 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 \texttt{pchannel}, write to a file, etc.) or use
\texttt{par\_lines} with a reducer. For ordered processing, use
\texttt{read\_lines} with \texttt{pmap} instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{par\_lines "data.txt", fn \{ process \}}

\NormalTok{\# Count matching lines in a large log:}
\NormalTok{my $count = 0}
\NormalTok{par\_lines "/var/log/syslog", fn \{ $count++ if /ERROR/ \}}
\NormalTok{p $count}

\NormalTok{\# Feed lines into a channel for downstream processing:}
\NormalTok{my ($tx, $rx) = pchannel(1000)}
\NormalTok{async \{ par\_lines "huge.csv", fn \{ $tx{-}\textgreater{}send(\_) \}}
\NormalTok{    undef $tx \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_walk}}{par\_walk}}\label{par_walk}

\texttt{par\_walk\ PATH,\ \{\ code\ \}} --- recursively walk a directory
tree in parallel, invoking the callback for every file path found.

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 \texttt{\_} (absolute).
This is significantly faster than a sequential \texttt{find}-style walk
on SSDs and networked filesystems where directory \texttt{readdir}
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 \texttt{dirs\ =\textgreater{}\ 1}. Combine
with \texttt{pmap} for a two-phase pattern: first collect paths with
\texttt{par\_walk}, then process file contents in parallel.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{par\_walk "./src", fn \{ p \_ if /\textbackslash{}.rs$/ \}}

\NormalTok{\# Collect all JSON files under a directory:}
\NormalTok{my @json\_files}
\NormalTok{par\_walk "/data", fn \{ push @json\_files, \_ if /\textbackslash{}.json$/ \}}
\NormalTok{p scalar @json\_files}

\NormalTok{\# Parallel content search:}
\NormalTok{par\_walk ".", fn \{}
\NormalTok{    if (/\textbackslash{}.log$/) \{}
\NormalTok{        my @hits = grep /FATAL/, rl}
\NormalTok{        p "$\_: ", scalar @hits, " fatals" if @hits}
\NormalTok{    \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_sed}}{par\_sed}}\label{par_sed}

\texttt{par\_sed\ PATTERN,\ REPLACEMENT,\ @files} --- perform an
in-place regex substitution across multiple files in parallel.

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 \texttt{sed\ -i} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{par\_sed qr/oldFunc/, "newFunc", glob("src/*.pl")}

\NormalTok{\# Case{-}insensitive replace across a project:}
\NormalTok{par\_sed qr/TODO/i, "DONE", par\_walk(".", fn \{ \_ if /\textbackslash{}.rs$/ \})}

\NormalTok{\# Scrub sensitive data from logs:}
\NormalTok{my $n = par\_sed qr/\textbackslash{}b\textbackslash{}d\{3\}{-}\textbackslash{}d\{2\}{-}\textbackslash{}d\{4\}\textbackslash{}b/, "XXX{-}XX{-}XXXX", @log\_files}
\NormalTok{p "redacted $n occurrences"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_find\_files}}{par\_find\_files}}\label{par_find_files}

Recursively search a directory tree in parallel for files matching a
glob pattern. Unlike \texttt{glob\_par} which takes a single pattern
string, \texttt{par\_find\_files} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @src = par\_find\_files("src", "*.rs")}
\NormalTok{p scalar @src                    \# count of Rust files under src/}
\NormalTok{my @tests = par\_find\_files(".", "*\_test.pl")}
\NormalTok{@tests |\textgreater{} e p}
\NormalTok{my @configs = par\_find\_files("/etc", "*.conf")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_line\_count}}{par\_line\_count}}\label{par_line_count}

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 \texttt{wc\ -l} for large file sets.
Useful for codebase metrics, log analysis, or validating data pipeline
output.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @files = glob("src/**/*.rs")}
\NormalTok{my $total = par\_line\_count(@files)}
\NormalTok{p "$total lines of Rust"}
\NormalTok{my $logs = par\_line\_count(glob("/var/log/*.log"))}
\NormalTok{p "$logs log lines"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_csv\_read}}{par\_csv\_read}}\label{par_csv_read}

\texttt{par\_csv\_read\ @files} --- read multiple CSV files in parallel,
returning an array of parsed datasets (one per file).

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 \texttt{par\_lines} with
manual splitting, since \texttt{par\_csv\_read} parallelizes across
files, not within a single file.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @datasets = par\_csv\_read glob("data/*.csv")}
\NormalTok{for my $ds (@datasets) \{}
\NormalTok{    p scalar @$ds, " rows"}
\NormalTok{\}}

\NormalTok{\# Merge all CSVs into one list:}
\NormalTok{my @all\_rows = par\_csv\_read(@files) |\textgreater{} flat}
\NormalTok{p $all\_rows[0]{-}\textgreater{}\{name\}                \# access by header}

\NormalTok{\# Filter and aggregate:}
\NormalTok{my @sales = par\_csv\_read(glob("sales\_*.csv")) |\textgreater{} flat}
\NormalTok{  |\textgreater{} grep \{ \_{-}\textgreater{}\{region\} eq "US" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glob\_par}}{glob\_par}}\label{glob_par}

Parallel recursive file-system glob using rayon across multiple
patterns. Backed by the same zshrs glob engine as \texttt{glob}, so
every zsh qualifier (\texttt{(/)}, \texttt{(.)}, \texttt{(L+1024)},
\texttt{(om{[}1{]})}, \ldots) is supported here too. Each pattern
expands single-threaded but the patterns run concurrently --- ideal for
many independent searches. For full qualifier reference see
\texttt{glob}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @logs = glob\_par("**/*.log")}
\NormalTok{p scalar @logs               \# count of log files}
\NormalTok{"**/*.rs" |\textgreater{} glob\_par |\textgreater{} e p  \# print all Rust files}
\NormalTok{my @imgs = glob\_par("assets/**/*.\{png,jpg,webp\}")}
\NormalTok{my @big\_recent = glob\_par("**(.L+1m om[1,5])")  \# 5 newest \textgreater{}1MB files}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pwatch}}{pwatch}}\label{pwatch}

\texttt{pwatch(PATTERN,\ fn\ \{\ ...\ \})} --- watch a path or glob
pattern for filesystem changes and invoke the callback on each event.

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 \texttt{\_}. 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 \texttt{debounce} or a \texttt{pchannel} if the
callback is expensive and rapid bursts of events need to be coalesced.

The initial expansion goes through the full zshrs glob engine, so zsh
qualifiers (\texttt{(.)}, \texttt{(/)}, \texttt{(L+1m)}, \ldots) work
for picking what to watch. The runtime event matcher uses the
qualifier-stripped pattern shape --- stat-based qualifiers
can\textquotesingle t apply to a single fired event, but they did apply
to the watch-set selection upfront.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $w = pwatch "./src/**/*.rs", fn \{}
\NormalTok{    p "changed: $\_"}
\NormalTok{    rebuild()}
\NormalTok{\}}

\NormalTok{my $logs = pwatch "logs/*(.)", fn \{ p "log updated: $\_" \}}
\NormalTok{my $cfg = pwatch "./config", fn \{ reload\_config() \}}
\NormalTok{sleep                                 \# block forever}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-file-i-o}
\chapter{File I/O}\label{file-io}

35 topics

\section{\texorpdfstring{\texttt{open}}{open}}\label{open}

Open a filehandle for reading, writing, appending, or piping. The
three-argument form \texttt{open\ my\ \$fh,\ MODE,\ EXPR} is strongly
preferred for safety --- it prevents shell injection and makes the mode
explicit. Modes include \texttt{\textless{}} (read),
\texttt{\textgreater{}} (write/truncate),
\texttt{\textgreater{}\textgreater{}} (append), \texttt{+\textless{}}
(read-write), \texttt{\textbar{}-} (pipe to command), and
\texttt{-\textbar{}} (pipe from command). In stryke, always use lexical
filehandles (\texttt{my\ \$fh}) rather than bareword globals. PerlIO
layers can be specified in the mode: \texttt{\textless{}:utf8},
\texttt{\textless{}:raw}, \texttt{\textless{}:encoding(UTF-16)}. Always
check the return value --- \texttt{open\ ...\ or\ die\ "...:\ \$!"} is
idiomatic. The \texttt{\$!} variable contains the OS error message on
failure. Forgetting to check \texttt{open} is one of the most common
bugs in Perl code.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{open my $fh, \textquotesingle{}\textless{}\textquotesingle{}, \textquotesingle{}data.txt\textquotesingle{} or die "open: $!"}
\NormalTok{my @lines = \textless{}$fh\textgreater{}}
\NormalTok{close $fh}

\NormalTok{open my $out, \textquotesingle{}\textgreater{}\textgreater{}\textquotesingle{}, \textquotesingle{}log.txt\textquotesingle{} or die "append: $!"}
\NormalTok{print $out tm "event happened\textbackslash{}n"}
\NormalTok{close $out}

\NormalTok{open my $pipe, \textquotesingle{}{-}|\textquotesingle{}, \textquotesingle{}ls\textquotesingle{}, \textquotesingle{}{-}la\textquotesingle{} or die "pipe: $!"}
\NormalTok{while (\textless{}$pipe\textgreater{}) \{ p tm \_ \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{close}}{close}}\label{close}

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,
\texttt{close} is where buffered data actually hits disk, so a full disk
or network error may only surface at \texttt{close} time. Always check
the return value when writing:
\texttt{close\ \$fh\ or\ die\ "close:\ \$!"}. For pipe handles opened
with \texttt{\textbar{}-} or \texttt{-\textbar{}}, \texttt{close} waits
for the child process to exit and sets \texttt{\$?} to the
child\textquotesingle s exit status. In stryke, lexical filehandles are
automatically closed when they go out of scope, but explicit
\texttt{close} is clearer and lets you handle errors.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{open my $fh, \textquotesingle{}\textgreater{}\textquotesingle{}, \textquotesingle{}out.txt\textquotesingle{} or die $!}
\NormalTok{print $fh "done\textbackslash{}n"}
\NormalTok{close $fh or die "write failed: $!"}

\NormalTok{open my $p, \textquotesingle{}|{-}\textquotesingle{}, \textquotesingle{}gzip\textquotesingle{}, \textquotesingle{}{-}c\textquotesingle{} or die $!}
\NormalTok{print $p $data}
\NormalTok{close $p}
\NormalTok{p "gzip exited: $?" if $?}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{read}}{read}}\label{read}

Read a specified number of bytes from a filehandle into a scalar buffer.
The signature is \texttt{read\ FH,\ SCALAR,\ LENGTH\ {[},\ OFFSET{]}}.
Returns the number of bytes actually read (which may be less than
requested at EOF or on partial reads), 0 at EOF, or \texttt{undef} 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\textquotesingle s PerlIO layer --- use \texttt{\textless{}:raw}
for binary data to avoid encoding transforms. In stryke, \texttt{read}
works identically to Perl 5. For line-oriented input, prefer
\texttt{\textless{}\$fh\textgreater{}} or \texttt{readline} instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{open my $fh, \textquotesingle{}\textless{}:raw\textquotesingle{}, $path or die $!}
\NormalTok{my $buf = \textquotesingle{}\textquotesingle{}}
\NormalTok{while (read $fh, my $chunk, 4096) \{}
\NormalTok{    $buf .= $chunk}
\NormalTok{\}}
\NormalTok{p "total: " . length($buf) . " bytes"}
\NormalTok{close $fh}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{readline}}{readline}}\label{readline}

Read one line (or all remaining lines in list context) from a
filehandle. The angle-bracket operator
\texttt{\textless{}\$fh\textgreater{}} is syntactic sugar for
\texttt{readline(\$fh)}. In scalar context, returns the next line
including the trailing newline (or \texttt{undef} at EOF). In list
context, returns all remaining lines as a list. The line ending is
determined by \texttt{\$/} (input record separator, default
\texttt{\textbackslash{}n}). Set \texttt{\$/\ =\ undef} to slurp the
entire file in one read. In stryke, \texttt{readline} integrates with
the pipe operator --- you can pipe filehandle lines through
\texttt{maps}, \texttt{greps}, and other streaming combinators. Always
\texttt{chomp} after reading if you don\textquotesingle t want trailing
newlines.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{while (my $line = \textless{}$fh\textgreater{}) \{}
\NormalTok{    chomp $line}
\NormalTok{    p $line}
\NormalTok{\}}

\NormalTok{\# Slurp entire file}
\NormalTok{local $/}
\NormalTok{my $content = \textless{}$fh\textgreater{}}
\NormalTok{p length $content}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eof}}{eof}}\label{eof}

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, \texttt{eof()} (with parens) checks the last file in the
\texttt{\textless{}\textgreater{}} / \texttt{ARGV} stream. Called with
no parens as \texttt{eof}, it tests whether the current ARGV file is
exhausted but more files may follow. In stryke, \texttt{eof} is
typically used in \texttt{until} loops or as a guard before
\texttt{read} calls. Note that \texttt{eof} 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,
\texttt{while\ (\textless{}\$fh\textgreater{})} is simpler and
implicitly handles EOF.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{until (eof $fh) \{}
\NormalTok{    my $line = \textless{}$fh\textgreater{}}
\NormalTok{    p tm $line}
\NormalTok{\}}

\NormalTok{\# Process multiple files via ARGV}
\NormalTok{while (\textless{}\textgreater{}) \{}
\NormalTok{    p "new file: $ARGV" if eof()}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seek}}{seek}}\label{seek}

Reposition a filehandle to an arbitrary byte offset. The signature is
\texttt{seek\ FH,\ POSITION,\ WHENCE} where WHENCE is 0 (absolute from
start), 1 (relative to current position), or 2 (relative to end of
file). Use the \texttt{Fcntl} constants \texttt{SEEK\_SET},
\texttt{SEEK\_CUR}, \texttt{SEEK\_END} for clarity. Returns 1 on
success, 0 on failure. \texttt{seek} 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, \texttt{seek} flushes
the PerlIO buffer before repositioning. Do not mix
\texttt{seek}/\texttt{tell} with \texttt{sysread}/\texttt{syswrite} ---
they use separate buffering layers.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{seek $fh, 0, 0         \# rewind to start}
\NormalTok{my $header = \textless{}$fh\textgreater{}}

\NormalTok{seek $fh, {-}100, 2      \# last 100 bytes}
\NormalTok{read $fh, my $tail, 100}
\NormalTok{p $tail}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tell}}{tell}}\label{tell}

Return the current byte offset of a filehandle\textquotesingle 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
\texttt{seek} back if the data doesn\textquotesingle t match
expectations. In stryke, \texttt{tell} reflects the PerlIO buffered
position, not the raw OS file descriptor position --- so it correctly
accounts for encoding layers and buffered reads. Pair with \texttt{seek}
for random-access patterns.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pos = tell $fh}
\NormalTok{p "at byte $pos"}

\NormalTok{\# Bookmark and restore}
\NormalTok{my $mark = tell $fh}
\NormalTok{my $line = \textless{}$fh\textgreater{}}
\NormalTok{unless ($line =\textasciitilde{} /\^{}HEADER/) \{}
\NormalTok{    seek $fh, $mark, 0   \# rewind to before the read}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{print}}{print}}\label{print}

Write operands to the selected output handle (default \texttt{STDOUT})
without appending a newline. The output field separator \texttt{\$,} is
inserted between arguments, and \texttt{\$\textbackslash{}} 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:
\texttt{print\ STDERR\ "msg"}. In stryke, \texttt{print} 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
\texttt{p} (say) instead since it handles the newline automatically.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{print "no newline"}
\NormalTok{print STDERR "error msg\textbackslash{}n"}
\NormalTok{print $fh "data to filehandle\textbackslash{}n"}
\NormalTok{for my $pct (0:100) \{}
\NormalTok{    printf "\textbackslash{}rprogress: \%3d\%\%", $pct}
\NormalTok{\}}
\NormalTok{print "\textbackslash{}n"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{say}}{say}}\label{say}

Print operands followed by an automatic newline to \texttt{STDOUT}. In
stryke, \texttt{say} is always available without \texttt{-E} or
\texttt{use\ feature\ \textquotesingle{}say\textquotesingle{}} --- it is
a first-class builtin. The shorthand \texttt{p} is an alias for
\texttt{say} and is preferred in most stryke code. When given a list,
\texttt{say} joins elements with \texttt{\$,} (output field separator,
empty by default) and appends \texttt{\$\textbackslash{}} plus a
newline. For streaming output over pipelines, combine with \texttt{e}
(each) to print one element per line. Gotcha: \texttt{say} always adds a
newline --- if you need raw output without one, use \texttt{print}
instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p "hello world"}
\NormalTok{my @names = ("alice", "bob", "eve")}
\NormalTok{@names |\textgreater{} e p}
\NormalTok{1:5 |\textgreater{} maps \{ \_ * 2 \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{printf}}{printf}}\label{printf}

Formatted print to a filehandle (default \texttt{STDOUT}), using C-style
format specifiers. The first argument is the format string with
\texttt{\%s} (string), \texttt{\%d} (integer), \texttt{\%f} (float),
\texttt{\%x} (hex), \texttt{\%o} (octal), \texttt{\%e} (scientific),
\texttt{\%g} (general float), and \texttt{\%\%} (literal percent). Width
and precision modifiers work as in C: \texttt{\%-10s} left-aligns in a
10-char field, \texttt{\%05d} zero-pads to 5 digits, \texttt{\%.2f}
gives 2 decimal places. In stryke, \texttt{printf} supports all standard
Perl 5 format specifiers including \texttt{\%v} (version strings) and
\texttt{\%n} is disabled for safety. Direct output to a handle by
placing it before the format: \texttt{printf\ STDERR\ "...",\ @args}.
Unlike \texttt{sprintf}, \texttt{printf} outputs directly and returns a
boolean indicating success.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{printf "\%{-}10s \%5d\textbackslash{}n", $name, $score}
\NormalTok{printf STDERR "error \%d: \%s\textbackslash{}n", $code, $msg}
\NormalTok{printf "\%08.2f\textbackslash{}n", 3.14159   \# 00003.14}
\NormalTok{printf "\%s has \%d item\%s\textbackslash{}n", $user, $n, $n == 1 ? "" : "s"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sprintf}}{sprintf}}\label{sprintf}

Return a formatted string without printing it, using the same C-style
format specifiers as \texttt{printf}. 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, \texttt{sprintf} is often combined with the pipe
operator:
\texttt{\$val\ \textbar{}\textgreater{}\ t\ \{\ sprintf\ "0x\%04x",\ \_\ \}\ \textbar{}\textgreater{}\ p}.
The return value is always a string. All format specifiers from
\texttt{printf} apply here.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $hex = sprintf "0x\%04x", 255}
\NormalTok{my $padded = sprintf "\%08d", $id}
\NormalTok{my $msg = sprintf "\%{-}20s: \%s", $key, $value}
\NormalTok{my @rows = map \{ sprintf "\%3d. \%s", \_, $names[\_] \} 0..$ \#names}
\NormalTok{@rows |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slurp}}{slurp}}\label{slurp}

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: \texttt{sl}, \texttt{cat}, \texttt{c}.
Dies if the file is missing or unreadable. For binary data use
\texttt{read\_bytes}/\texttt{slurp\_raw}.

When the path contains glob metacharacters (\texttt{*} \texttt{?}
\texttt{{[}} \texttt{**}) or a trailing zsh qualifier suffix
\texttt{(...)}, it is expanded by the zshrs glob engine and the results
are concatenated. \textbf{\texttt{slurp} hard-fails if the qualifier
yields any non-regular file} --- \texttt{slurp\ "**(/)"} errors
\texttt{slurp:\ not\ a\ regular\ file:\ ./sub} because slurping a
directory is meaningless. To list directory paths, use
\texttt{glob\ "**(/)"}. See \texttt{glob} for the full qualifier
reference.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $text = slurp("config.yaml")}
\NormalTok{my $all = c("**(.)")               \# every regular file recursively, concatenated}
\NormalTok{my $logs = c("logs/*.log")          \# all logs in one go}
\NormalTok{my $json = sl("data.json")}
\NormalTok{my $data = decode\_json($json)}
\NormalTok{"README.md" |\textgreater{} sl |\textgreater{} length |\textgreater{} p    \# character count}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slurp\_raw}}{slurp\_raw}}\label{slurp_raw}

Read an entire file into memory as raw bytes without any encoding
interpretation. Unlike \texttt{slurp}, which returns a decoded UTF-8
string, \texttt{read\_bytes} preserves the exact byte content --- useful
for binary files like images, compressed archives, or protocol buffers.
The alias \texttt{slurp\_raw} emphasizes the raw nature.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $png = read\_bytes("logo.png")}
\NormalTok{p length($png)                        \# byte count}
\NormalTok{my $gz = slurp\_raw("data.gz")}
\NormalTok{my $text = gunzip($gz)}
\NormalTok{p $text}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{input}}{input}}\label{input}

Slurp all of stdin (or a filehandle) as one string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $all = input          \# slurp stdin}
\NormalTok{my $fh\_data = input($fh) \# slurp filehandle}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{read\_lines}}{read\_lines}}\label{read_lines}

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 \texttt{rl} keeps one-liners concise. If the file does not exist,
the program dies with an error message.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @lines = rl("data.txt")}
\NormalTok{p scalar @lines               \# line count}
\NormalTok{@lines |\textgreater{} grep /ERROR/ |\textgreater{} e p \# print error lines}
\NormalTok{my $first = (rl "config.ini")[0]$1}

\NormalTok{Note: returns an empty list for an empty file.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{append\_file}}{append\_file}}\label{append_file}

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
\texttt{af} is convenient in pipelines. The file is opened, written, and
closed atomically per call.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{af("log.txt", "started at " . datetime\_utc() . "\textbackslash{}n")}
\NormalTok{1:5 |\textgreater{} e \{ af("nums.txt", "$\_\textbackslash{}n") \}}
\NormalTok{my @data = ("a","b","c")}
\NormalTok{@data |\textgreater{} e \{ af "out.txt", "$\_\textbackslash{}n" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_file}}{to\_file}}\label{to_file}

Write a string to a file, truncating any existing content. Unlike
\texttt{append\_file}, 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $csv = "name,age\textbackslash{}nAlice,30\textbackslash{}nBob,25"}
\NormalTok{$csv |\textgreater{} to\_file("people.csv") |\textgreater{} p}
\NormalTok{to\_file("empty.txt", "")  \# truncate a file}
\end{Highlighting}
\end{Shaded}

Note: the return-value-for-piping behavior distinguishes this from a
plain write.

\section{\texorpdfstring{\texttt{write}}{write}}\label{write}

Output a formatted record to a filehandle using a \texttt{format}
declaration. \texttt{write} looks up the format associated with the
current (or specified) filehandle, evaluates the
format\textquotesingle s picture lines against the current variables,
and outputs the result. This is Perl\textquotesingle s original
report-generation mechanism, predating modules like \texttt{Text::Table}
and template engines. In stryke, \texttt{write} and \texttt{format} are
supported for backward compatibility but are rarely used in new code ---
\texttt{printf}/\texttt{sprintf} or template strings are more flexible.
The format name defaults to the filehandle name (e.g., format
\texttt{STDOUT} is used by \texttt{write\ STDOUT}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{format STDOUT =}
\NormalTok{@\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{} @\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textgreater{}}
\NormalTok{$name,       $score}
\NormalTok{.}

\NormalTok{my ($name, $score) = ("alice", 42)}
\NormalTok{write   \# outputs: alice           42}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{write\_file}}{write\_file}}\label{write_file}

Write a string to a file, creating it if it does not exist or truncating
it if it does. This is the complement of \texttt{slurp} --- together
they form a read/write pair for whole-file operations. The short alias
\texttt{wf} is convenient for one-liners. The file is opened, written,
and closed in a single call.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{spurt("hello.txt", "Hello, world!\textbackslash{}n")}
\NormalTok{wf("nums.txt", join("\textbackslash{}n", 1:10))}
\NormalTok{"generated content" |\textgreater{} wf("out.txt")}
\NormalTok{my $data = slurp("in.txt")}
\NormalTok{wf("copy.txt", $data)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{write\_json}}{write\_json}}\label{write_json}

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 \texttt{wj} pairs with \texttt{rj} for
round-trip JSON workflows. Useful for persisting configuration, caching
API responses, or generating fixture data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%data = (name =\textgreater{} "Alice", scores =\textgreater{} [98, 87, 95])}
\NormalTok{wj("out.json", \textbackslash{}\%data)}
\NormalTok{my $back = rj("out.json")}
\NormalTok{p $back{-}\textgreater{}\{name\}   \# Alice}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{read\_json}}{read\_json}}\label{read_json}

Read a JSON file from disk and parse it into a stryke data structure
(hash ref or array ref). The short alias \texttt{rj} keeps JSON-config
one-liners terse. Dies if the file does not exist or contains malformed
JSON. This is the complement of \texttt{write\_json}/\texttt{wj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cfg = rj("config.json")}
\NormalTok{p $cfg{-}\textgreater{}\{database\}\{host\}}
\NormalTok{my @items = @\{ rj("list.json") \}}
\NormalTok{@items |\textgreater{} e \{ p \_{-}\textgreater{}\{name\} \}$1}

\NormalTok{Note: numeric strings remain strings; use \textasciigrave{}+0\textasciigrave{} to coerce if needed.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tempfile}}{tempfile}}\label{tempfile}

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 \texttt{tf} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $tmp = tf()}
\NormalTok{to\_file($tmp, "scratch data\textbackslash{}n")}
\NormalTok{p rl($tmp)           \# scratch data}
\NormalTok{my @all = map \{ tf() \} 1:3  \# three temp files}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tempdir}}{tempdir}}\label{tempdir}

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 \texttt{tdr} mirrors \texttt{tf}
for files. Useful for isolating multi-file operations like test
fixtures, build artifacts, or staged output.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $dir = tdr()}
\NormalTok{to\_file("$dir/a.txt", "hello")}
\NormalTok{to\_file("$dir/b.txt", "world")}
\NormalTok{my @files = glob("$dir/*.txt")}
\NormalTok{p scalar @files   \# 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binmode}}{binmode}}\label{binmode}

Set the I/O layer on a filehandle, controlling how bytes are translated
during reads and writes. Without a layer argument,
\texttt{binmode\ \$fh} switches the handle to raw binary mode (no CRLF
translation on Windows, no encoding transforms). With a layer,
\texttt{binmode\ \$fh,\ \textquotesingle{}:utf8\textquotesingle{}}
enables UTF-8 decoding,
\texttt{binmode\ \$fh,\ \textquotesingle{}:raw\textquotesingle{}} strips
all layers for pure byte I/O, and
\texttt{binmode\ \$fh,\ \textquotesingle{}:encoding(ISO-8859-1)\textquotesingle{}}
sets a specific encoding. In stryke, encoding layers can also be
specified directly in \texttt{open}:
\texttt{open\ my\ \$fh,\ \textquotesingle{}\textless{}:utf8\textquotesingle{},\ \$path}.
Call \texttt{binmode} 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 \texttt{:raw}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{open my $fh, \textquotesingle{}\textless{}\textquotesingle{}, $path or die $!}
\NormalTok{binmode $fh, \textquotesingle{}:utf8\textquotesingle{}}
\NormalTok{my @lines = \textless{}$fh\textgreater{}}

\NormalTok{open my $bin, \textquotesingle{}\textless{}\textquotesingle{}, $img\_path or die $!}
\NormalTok{binmode $bin, \textquotesingle{}:raw\textquotesingle{}}
\NormalTok{read $bin, my $header, 8}
\NormalTok{p sprintf "magic: \%s", unpack("H*", $header)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fileno}}{fileno}}\label{fileno}

Return the underlying OS file descriptor number for a filehandle, or
\texttt{undef} 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, \texttt{fileno} is rarely
needed in everyday code but is essential for low-level I/O multiplexing
and process management.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $fd = fileno STDOUT}
\NormalTok{p "stdout fd: $fd"   \# 1}

\NormalTok{if (defined fileno $fh) \{}
\NormalTok{    p "handle is backed by fd " . fileno($fh)}
\NormalTok{\} else \{}
\NormalTok{    p "not a real file descriptor"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flock}}{flock}}\label{flock}

Advisory file locking for coordinating access between processes.
\texttt{flock\ \$fh,\ OPERATION} where OPERATION is \texttt{LOCK\_SH}
(shared/read lock), \texttt{LOCK\_EX} (exclusive/write lock), or
\texttt{LOCK\_UN} (unlock). Add \texttt{LOCK\_NB} for non-blocking mode:
\texttt{LOCK\_EX\ \textbar{}\ LOCK\_NB} returns false immediately if the
lock is held rather than waiting. Import constants from \texttt{Fcntl}.
Advisory locks are cooperative --- they only work if all processes
accessing the file use \texttt{flock}. In stryke, \texttt{flock} 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: \texttt{flock} does not
work on NFS on many systems.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{use Fcntl \textquotesingle{}:flock\textquotesingle{}}
\NormalTok{open my $fh, \textquotesingle{}\textgreater{}\textgreater{}\textquotesingle{}, \textquotesingle{}shared.log\textquotesingle{} or die $!}
\NormalTok{flock $fh, LOCK\_EX or die "lock: $!"}
\NormalTok{print $fh tm "pid $$ wrote this\textbackslash{}n"}
\NormalTok{flock $fh, LOCK\_UN}
\NormalTok{close $fh}

\NormalTok{unless (flock $fh, LOCK\_EX | LOCK\_NB) \{}
\NormalTok{    p "file is locked by another process"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getc}}{getc}}\label{getc}

Read a single character from a filehandle (default \texttt{STDIN}).
Returns \texttt{undef} at EOF. The character returned respects the
handle\textquotesingle s encoding layer --- under \texttt{:utf8},
\texttt{getc} 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, \texttt{getc} blocks until a
character is available on the handle. For terminal input, note that most
terminals are line-buffered by default, so \texttt{getc\ STDIN}
won\textquotesingle t return until the user presses Enter unless you put
the terminal into raw mode.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ch = getc STDIN}
\NormalTok{p "you pressed: $ch"}

\NormalTok{open my $fh, \textquotesingle{}\textless{}:utf8\textquotesingle{}, $path or die $!}
\NormalTok{while (defined(my $c = getc $fh)) \{}
\NormalTok{    p "char: $c (ord " . ord($c) . ")"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{select}}{select}}\label{select}

In its one-argument form, \texttt{select\ HANDLE} sets the default
output handle for \texttt{print}, \texttt{say}, and \texttt{write},
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,
\texttt{select\ RBITS,\ WBITS,\ EBITS,\ TIMEOUT} performs POSIX
\texttt{select(2)} 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 \texttt{IO::Select} or async I/O patterns for
multiplexing. \texttt{select} with \texttt{\$\textbar{}} is also the
classic way to enable autoflush on a handle.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $old = select STDERR}
\NormalTok{p "this goes to stderr"}
\NormalTok{select $old}

\NormalTok{\# Enable autoflush on STDOUT}
\NormalTok{select STDOUT; $| = 1}
\NormalTok{print "immediately flushed"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{truncate}}{truncate}}\label{truncate}

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. \texttt{truncate\ \$fh,\ 0} empties the file entirely --- a
common pattern when rewriting a file in place.
\texttt{truncate\ \$fh,\ \$len} discards everything beyond byte
\texttt{\$len}. Returns true on success, false on failure (check
\texttt{\$!} for the error). In stryke, truncate works on any seekable
filehandle. When using truncate to rewrite a file, remember to also
\texttt{seek\ \$fh,\ 0,\ 0} to rewind the write position --- truncating
does not move the file pointer. Gotcha: truncating a file opened
read-only will fail.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{open my $fh, \textquotesingle{}+\textless{}\textquotesingle{}, \textquotesingle{}data.txt\textquotesingle{} or die $!}
\NormalTok{truncate $fh, 0       \# empty the file}
\NormalTok{seek $fh, 0, 0        \# rewind to start}
\NormalTok{print $fh "fresh content\textbackslash{}n"}
\NormalTok{close $fh}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sysopen}}{sysopen}}\label{sysopen}

Low-level open using POSIX flags for precise control over how a file is
opened. The signature is
\texttt{sysopen\ FH,\ FILENAME,\ FLAGS\ {[},\ PERMS{]}}. Flags are
bitwise-OR combinations from \texttt{Fcntl}: \texttt{O\_RDONLY},
\texttt{O\_WRONLY}, \texttt{O\_RDWR}, \texttt{O\_CREAT},
\texttt{O\_EXCL}, \texttt{O\_TRUNC}, \texttt{O\_APPEND},
\texttt{O\_NONBLOCK}, and others. The optional PERMS argument (e.g.,
\texttt{0644}) sets the file mode when \texttt{O\_CREAT} creates a new
file, subject to the process umask. \texttt{sysopen} is the right tool
when you need \texttt{O\_EXCL} for atomic file creation (lock files,
temp files), \texttt{O\_NONBLOCK} for non-blocking I/O, or other flags
that \texttt{open} cannot express. In stryke, prefer three-argument
\texttt{open} for routine file access and reserve \texttt{sysopen} for
cases requiring specific POSIX semantics.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{use Fcntl}
\NormalTok{\# Atomic create — fails if file already exists}
\NormalTok{sysopen my $lock, \textquotesingle{}/tmp/my.lock\textquotesingle{}, O\_WRONLY|O\_CREAT|O\_EXCL, 0644}
\NormalTok{    or die "already running: $!"}
\NormalTok{print $lock $$}

\NormalTok{sysopen my $log, \textquotesingle{}app.log\textquotesingle{}, O\_WRONLY|O\_APPEND|O\_CREAT, 0644}
\NormalTok{    or die "open log: $!"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sysread}}{sysread}}\label{sysread}

Low-level unbuffered read directly from a file descriptor, bypassing
PerlIO buffering layers. The signature is
\texttt{sysread\ FH,\ SCALAR,\ LENGTH\ {[},\ OFFSET{]}}. Returns the
number of bytes read, 0 at EOF, or \texttt{undef} on error. Unlike
\texttt{read}, \texttt{sysread} issues a single \texttt{read(2)} 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 \texttt{sysread}/\texttt{syswrite} with
buffered I/O (\texttt{print}, \texttt{read},
\texttt{\textless{}\$fh\textgreater{}}) on the same handle --- the
buffered and unbuffered positions will diverge and produce corrupted
reads.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{open my $fh, \textquotesingle{}\textless{}:raw\textquotesingle{}, $path or die $!}
\NormalTok{my $buf = \textquotesingle{}\textquotesingle{}}
\NormalTok{while (my $n = sysread $fh, $buf, 4096, length($buf)) \{}
\NormalTok{    p "read $n bytes (total: " . length($buf) . ")"}
\NormalTok{\}}
\NormalTok{close $fh}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{syswrite}}{syswrite}}\label{syswrite}

Low-level unbuffered write directly to a file descriptor, bypassing
PerlIO buffering layers. The signature is
\texttt{syswrite\ FH,\ SCALAR\ {[},\ LENGTH\ {[},\ OFFSET{]}{]}}.
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 \texttt{undef} on error. Like \texttt{sysread},
this issues a single \texttt{write(2)} system call and must not be mixed
with buffered I/O on the same handle. In stryke, \texttt{syswrite} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $data = "hello, world"}
\NormalTok{my $n = syswrite $fh, $data}
\NormalTok{p "wrote $n bytes"}

\NormalTok{\# Robust write loop for sockets}
\NormalTok{my $off = 0}
\NormalTok{while ($off \textless{} length $data) \{}
\NormalTok{    my $written = syswrite $fh, $data, length($data) {-} $off, $off}
\NormalTok{    die "syswrite: $!" unless defined $written}
\NormalTok{    $off += $written}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sysseek}}{sysseek}}\label{sysseek}

Low-level seek on a file descriptor, bypassing PerlIO buffering. The
signature is \texttt{sysseek\ FH,\ POSITION,\ WHENCE} with the same
WHENCE values as \texttt{seek} (0=start, 1=current, 2=end). Returns the
new position as a true value, or \texttt{undef} on failure. Unlike
\texttt{seek}, \texttt{sysseek} does not flush PerlIO buffers --- it
operates directly on the underlying OS file descriptor. Use
\texttt{sysseek} when working with \texttt{sysread}/\texttt{syswrite}
for consistent positioning. In stryke, \texttt{sysseek} with
\texttt{SEEK\_CUR} and position 0 is an idiom for querying the current
fd position without moving:
\texttt{my\ \$pos\ =\ sysseek\ \$fh,\ 0,\ 1}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{sysseek $fh, 0, 0   \# rewind to start}
\NormalTok{sysread $fh, my $buf, 512}

\NormalTok{my $pos = sysseek $fh, 0, 1}
\NormalTok{p "fd position: $pos"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{format}}{format}}\label{format}

Declare a picture-format template for generating fixed-width text
reports. The syntax is \texttt{format\ NAME\ =\ ...\ .} where each line
alternates between picture lines (containing field placeholders) and
argument lines (listing the variables to fill in). Placeholders include
\texttt{@\textless{}\textless{}\textless{}\textless{}} (left-align),
\texttt{@\textgreater{}\textgreater{}\textgreater{}\textgreater{}}
(right-align), \texttt{@\textbar{}\textbar{}\textbar{}\textbar{}}
(center), \texttt{@\#\#\#.\#\#} (numeric with decimal), and \texttt{@*}
(multiline block fill). The format ends with a lone \texttt{.} on its
own line. In stryke, formats are a legacy feature preserved for
compatibility with Perl 5 code --- for new reports, prefer
\texttt{printf}/\texttt{sprintf} for simple alignment or a templating
module for complex layouts. Formats interact with the special variables
\texttt{\$\textasciitilde{}} (current format name), \texttt{\$\^{}}
(header format), and \texttt{\$=} (lines per page).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{format REPORT =}
\NormalTok{@\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{}\textless{} @\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textgreater{} @ \#\#\#.\#\#}
\NormalTok{$item,            $qty,  $price}
\NormalTok{.}

\NormalTok{my ($item, $qty, $price) = ("Widget", 100, 9.99)}
\NormalTok{my $old = select REPORT}
\NormalTok{$\textasciitilde{} = \textquotesingle{}REPORT\textquotesingle{}}
\NormalTok{write REPORT}
\NormalTok{select $old}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{formline}}{formline}}\label{formline}

Format a line of output according to a picture template, appending the
result to the \texttt{\$\^{}A} (format accumulator) variable. This is
the low-level engine behind Perl\textquotesingle s
\texttt{format}/\texttt{write} report-generation system. Template
characters like \texttt{@\textless{}\textless{}\textless{}}
(left-justify), \texttt{@\textgreater{}\textgreater{}\textgreater{}}
(right-justify), and \texttt{@\#\#\#.\#\#} (numeric) control field
placement.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{$\^{}A = ""}
\NormalTok{formline("@\textless{}\textless{}\textless{}\textless{} @\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textbackslash{}n", "Name", "Score")}
\NormalTok{formline("@\textless{}\textless{}\textless{}\textless{} @\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textbackslash{}n", "Alice", 98)}
\NormalTok{formline("@\textless{}\textless{}\textless{}\textless{} @\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textgreater{}\textbackslash{}n", "Bob", 85)}
\NormalTok{p $\^{}A}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-strings}
\chapter{Strings}\label{strings}

26 topics

\section{\texorpdfstring{\texttt{chomp}}{chomp}}\label{chomp}

\texttt{chomp\ STRING} --- remove the trailing record separator (usually
\texttt{\textbackslash{}n}) from a string in place and return the number
of characters removed.

\texttt{chomp} is the idiomatic way to strip newlines after reading
input; unlike \texttt{chop}, it only removes the value of \texttt{\$/}
(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
\texttt{chomp} an entire array to strip every element at once. In
stryke, \texttt{chomp} operates on UTF-8 strings and respects multi-byte
\texttt{\$/} values. Prefer \texttt{chomp} over \texttt{chop} in
virtually all input-processing code; \texttt{chop} is only for when you
truly need to remove an arbitrary trailing character regardless of what
it is.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $line = \textless{}STDIN\textgreater{}}
\NormalTok{chomp $line}
\NormalTok{p $line}
\NormalTok{chomp(my @lines = \textless{}$fh\textgreater{})  \# strip all at once}
\NormalTok{p scalar @lines}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chop}}{chop}}\label{chop}

\texttt{chop\ STRING} --- remove and return the last character of a
string, modifying the string in place.

Unlike \texttt{chomp}, \texttt{chop} 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 \texttt{chop} 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 \texttt{\textbackslash{}n}. When called on an array, \texttt{chop}
removes the last character of every element and returns the last one
removed.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = "hello!"}
\NormalTok{my $last = chop $s  \# $last = "!", $s = "hello"}
\NormalTok{p $s}
\NormalTok{my @words = ("foo\textbackslash{}n", "bar\textbackslash{}n")}
\NormalTok{chop @words  \# strips trailing newline from each}
\NormalTok{@words |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{length}}{length}}\label{length}

\texttt{length\ STRING} --- return the \textbf{byte} length of a string.
Perl 5 builtin; pairs with \texttt{index} / \texttt{rindex} /
\texttt{substr} (all byte-based) so positions and lengths share a
coordinate system.

\texttt{length\ "hello"} is 5; \texttt{length\ "─"} is 3 (the
box-drawing char takes 3 bytes in UTF-8). For codepoint count, use
\texttt{len} (stryke extension), which mirrors \texttt{{[}i{]}} /
\texttt{{[}a:b{]}} slice semantics.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p length "hello"      \# 5}
\NormalTok{p length "─"          \# 3 (bytes)}
\NormalTok{p len "─"             \# 1 (codepoint)}
\NormalTok{p length "\textbackslash{}x\{1F600\}"  \# 4 (bytes — emoji is 4{-}byte UTF{-}8)}
\NormalTok{p len "\textbackslash{}x\{1F600\}"     \# 1 (codepoint)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{substr}}{substr}}\label{substr}

\texttt{substr\ STRING,\ OFFSET\ {[},\ LENGTH\ {[},\ REPLACEMENT{]}{]}}
--- extract or replace a substring.

\texttt{substr} is stryke\textquotesingle 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
(\texttt{substr\ \$s,\ -3} gives the last three characters). In stryke,
offsets are UTF-8 character positions, making it safe for multi-byte
text. \texttt{substr} as an lvalue
(\texttt{substr(\$s,\ 0,\ 1)\ =\ "X"}) is also supported for in-place
mutation. Prefer \texttt{substr} over regex when you know exact
positions --- it is faster and clearer.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = "hello world"}
\NormalTok{p substr $s, 0, 5              \# hello}
\NormalTok{p substr $s, {-}5                \# world}
\NormalTok{substr $s, 6, 5, "stryke"     \# $s = "hello stryke"}
\NormalTok{p $s}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index}}{index}}\label{index}

\texttt{index\ STRING,\ SUBSTRING\ {[},\ POSITION{]}} --- return the
zero-based \textbf{byte} position of the first occurrence of SUBSTRING
within STRING, or -1 if not found. Pairs with \texttt{substr} and
\texttt{length} (both byte-based) for Perl 5 compat.

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 \texttt{index} repeatedly, advancing POSITION past each hit).
For multi-byte strings where you want \textbf{codepoint} positions
paired with \texttt{{[}i{]}} / \texttt{{[}a:b{]}} slice operators, use
\texttt{cindex} (stryke extension) instead --- \texttt{index} is
byte-indexed because \texttt{length} and \texttt{substr} are, and
changing it would break Perl 5 binary-protocol code.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $i = index "hello world", "world"  \# 6}
\NormalTok{p $i}
\NormalTok{my $s = "a.b.c.d"}
\NormalTok{my $pos = 0}
\NormalTok{while (($pos = index $s, ".", $pos) != {-}1) \{}
\NormalTok{    p "dot at $pos"}
\NormalTok{    $pos++}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rindex}}{rindex}}\label{rindex}

\texttt{rindex\ STRING,\ SUBSTRING\ {[},\ POSITION{]}} --- return the
zero-based \textbf{byte} position of the last occurrence of SUBSTRING
within STRING, searching backward from POSITION (or the end). Mirror of
\texttt{index}; pairs with \texttt{substr} and \texttt{length} for Perl
5 compat.

\texttt{rindex} 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
\texttt{{[}{]}} slice operators, use \texttt{crindex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $path = "foo/bar/baz.tar.gz"}
\NormalTok{my $i = rindex $path, "/"     \# 7}
\NormalTok{p substr $path, $i + 1        \# baz.tar.gz}
\NormalTok{my $ext = rindex $path, "."   \# 15}
\NormalTok{p substr $path, $ext + 1      \# gz}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{split}}{split}}\label{split}

\texttt{split\ /PATTERN/,\ STRING\ {[},\ LIMIT{]}} --- divide STRING
into a list of substrings by splitting on each occurrence of PATTERN.

\texttt{split} 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 \texttt{"\ "} (a
single space string, not regex) mimics \texttt{awk}-style splitting: it
strips leading whitespace and splits on runs of whitespace. In stryke,
\texttt{split} integrates with \texttt{\textbar{}\textgreater{}}
pipelines, accepting piped-in strings for ergonomic one-liners. Trailing
empty fields are removed by default; pass -1 as LIMIT to preserve them.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @parts = split /,/, "a,b,c"}
\NormalTok{"one:two:three" |\textgreater{} split /:/ |\textgreater{} e p   \# one two three}
\NormalTok{my ($user, $domain) = split /@/, $email, 2}
\NormalTok{p "$user at $domain"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join}}{join}}\label{join}

\texttt{join\ SEPARATOR,\ LIST} --- concatenate all elements of LIST
into a single string, placing SEPARATOR between each pair of adjacent
elements.

\texttt{join} is the inverse of \texttt{split}. It stringifies each
element before joining, so mixing numbers and strings is fine. An empty
separator (\texttt{join\ "",\ @list}) concatenates without gaps. In
stryke, \texttt{join} works naturally with
\texttt{\textbar{}\textgreater{}} pipelines: a range or filtered list
can be piped directly into \texttt{join} with a separator argument. This
is the standard way to build CSV lines, path strings, or human-readable
lists from arrays. \texttt{join} never adds a trailing separator --- if
you need one, append it yourself.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $csv = join ",", @fields}
\NormalTok{1:5 |\textgreater{} join "{-}" |\textgreater{} p   \# 1{-}2{-}3{-}4{-}5}
\NormalTok{my @parts = ("usr", "local", "bin")}
\NormalTok{p join "/", "", @parts   \# /usr/local/bin}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uc}}{uc}}\label{uc}

\texttt{uc\ STRING} --- return a fully uppercased copy of the string.

\texttt{uc} 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 \texttt{uc} for
normalizing strings before comparison, formatting headers, or
transforming pipeline output. In stryke
\texttt{\textbar{}\textgreater{}} chains, combine with \texttt{maps} or
\texttt{t} for streaming uppercase transforms. For uppercasing only the
first character (e.g., sentence capitalization), use \texttt{ucfirst}
instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p uc "hello"  \# HELLO}
\NormalTok{@words |\textgreater{} maps \{ uc \} |\textgreater{} e p}
\NormalTok{"whisper" |\textgreater{} t uc |\textgreater{} p   \# WHISPER}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lc}}{lc}}\label{lc}

\texttt{lc\ STRING} --- return a fully lowercased copy of the string.

\texttt{lc} performs Unicode-aware lowercasing in stryke, so
\texttt{lc\ "\textbackslash{}x\{C4\}"} (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:
\texttt{if\ (lc\ \$a\ eq\ lc\ \$b)}. In stryke
\texttt{\textbar{}\textgreater{}} pipelines, wrap \texttt{lc} with
\texttt{t} to apply it as a streaming transform. For lowercasing only
the first character, use \texttt{lcfirst} instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lc "HELLO"               \# hello}
\NormalTok{"SHOUT" |\textgreater{} t lc |\textgreater{} t rev |\textgreater{} p  \# tuohs}
\NormalTok{my @norm = map lc, @words}
\NormalTok{@norm |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ucfirst}}{ucfirst}}\label{ucfirst}

\texttt{ucfirst\ STRING} --- return a copy of the string with only the
first character uppercased, leaving the rest unchanged.

This is the standard way to capitalize the first letter of a word for
display, title-casing, or converting camelCase to PascalCase. In stryke,
\texttt{ucfirst} 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 \texttt{uc}. A common idiom is
\texttt{ucfirst\ lc\ \$word} to normalize a word to "Title" form.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ucfirst "hello"            \# Hello}
\NormalTok{p ucfirst lc "hELLO"         \# Hello}
\NormalTok{my @titled = map \{ ucfirst lc \} @raw}
\NormalTok{@titled |\textgreater{} join " " |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcfirst}}{lcfirst}}\label{lcfirst}

\texttt{lcfirst\ STRING} --- return a copy of the string with only the
first character lowercased, leaving the rest unchanged.

This is useful for converting PascalCase identifiers to camelCase, or
for formatting output where only the initial letter matters. In stryke,
\texttt{lcfirst} is Unicode-aware, so it handles accented capitals and
multi-byte first characters correctly. Like \texttt{lc}, it returns a
new string rather than modifying in place. If you need the entire string
lowercased, use \texttt{lc} instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lcfirst "Hello"    \# hello}
\NormalTok{p lcfirst "XMLParser" \# xMLParser}
\NormalTok{my @camel = map lcfirst, @PascalNames}
\NormalTok{@camel |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chr}}{chr}}\label{chr}

\texttt{chr\ NUMBER} --- return the character represented by the given
ASCII or Unicode code point.

\texttt{chr} is the inverse of \texttt{ord}:
\texttt{chr(ord(\$c))\ eq\ \$c} 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
\texttt{chr\ 0x1F600} gives you a smiley emoji with no special encoding
gymnastics. For string literals, stryke supports all standard escapes:
\texttt{\textbackslash{}x\{hex\}}, \texttt{\textbackslash{}u\{hex\}},
\texttt{\textbackslash{}o\{oct\}}, \texttt{\textbackslash{}NNN} (octal),
\texttt{\textbackslash{}cX} (control),
\texttt{\textbackslash{}N\{U+hex\}},
\texttt{\textbackslash{}N\{UNICODE\ NAME\}}, plus case modifiers
\texttt{\textbackslash{}U..\textbackslash{}E},
\texttt{\textbackslash{}L..\textbackslash{}E},
\texttt{\textbackslash{}u}, \texttt{\textbackslash{}l},
\texttt{\textbackslash{}Q..\textbackslash{}E}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p chr 65       \# A}
\NormalTok{p chr 0x1F600  \# smiley emoji}
\NormalTok{p "\textbackslash{}u\{0301\}"   \# combining acute accent}
\NormalTok{p "\textbackslash{}N\{SNOWMAN\}" \# ☃}
\NormalTok{my @abc = map \{ chr(\_ + 64) \} 1:26}
\NormalTok{@abc |\textgreater{} join "" |\textgreater{} p  \# ABCDEFGHIJKLMNOPQRSTUVWXYZ}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ord}}{ord}}\label{ord}

\texttt{ord\ STRING} --- return the numeric (Unicode code point) value
of the first character of the string.

\texttt{ord} is the inverse of \texttt{chr}:
\texttt{ord(chr(\$n))\ ==\ \$n} always holds. When passed a
multi-character string, only the first character is examined --- the
rest are ignored. In stryke, \texttt{ord} returns the full Unicode code
point, not just 0-255, so \texttt{ord\ "\textbackslash{}u\{1F600\}"}
returns 128512. This is useful for character classification, building
lookup tables, or implementing custom encodings. For ASCII checks,
\texttt{ord(\$c)\ \textgreater{}=\ 32\ \&\&\ ord(\$c)\ \textless{}=\ 126}
tests printability.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ord "A"          \# 65}
\NormalTok{p ord "\textbackslash{}n"         \# 10}
\NormalTok{p ord "\textbackslash{}u\{1F600\}"  \# 128512}
\NormalTok{my @codes = map ord, split //, "hello"}
\NormalTok{@codes |\textgreater{} e p      \# 104 101 108 108 111}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex}}{hex}}\label{hex}

\texttt{hex\ STRING} --- interpret a hexadecimal string and return its
numeric value.

The leading \texttt{0x} prefix is optional: both \texttt{hex\ "ff"} and
\texttt{hex\ "0xff"} return 255. The string is case-insensitive, so
\texttt{hex\ "DeAdBeEf"} 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 \texttt{sprintf\ "\%x"}. Note that \texttt{hex} always
returns a number, never a string --- arithmetic is immediate.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $n = hex "deadbeef"}
\NormalTok{printf "0x\%x = \%d\textbackslash{}n", $n, $n}
\NormalTok{p hex "ff"   \# 255}
\NormalTok{"cafe" |\textgreater{} t \{ hex \} |\textgreater{} p   \# 51966}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oct}}{oct}}\label{oct}

\texttt{oct\ STRING} --- interpret an octal, hexadecimal, or binary
string and return its numeric value.

\texttt{oct} is the multi-base cousin of \texttt{hex}: it auto-detects
the base from the prefix. Strings starting with \texttt{0b} are binary,
\texttt{0x} are hex, and bare digits or \texttt{0}-prefixed digits are
octal. This makes it the go-to for parsing Unix file permissions
(\texttt{oct\ "0755"} gives 493), binary literals, or any string where
the radix is embedded in the value. In stryke, \texttt{oct} handles
arbitrarily large integers via the same big-number pathway as other
arithmetic. A common gotcha: \texttt{oct\ "8"} warns because 8 is not a
valid octal digit --- use \texttt{hex} or a bare numeric literal
instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p oct "0755"    \# 493}
\NormalTok{p oct "0b1010"  \# 10}
\NormalTok{p oct "0xff"    \# 255}
\NormalTok{my $perms = oct "644"}
\NormalTok{p sprintf "\%04o", $perms  \# 0644}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quotemeta}}{quotemeta}}\label{quotemeta}

\texttt{quotemeta\ STRING} --- escape all non-alphanumeric characters
with backslashes, returning a string safe for interpolation into a
regex.

This is essential when building dynamic regexes from user input: without
\texttt{quotemeta}, characters like \texttt{.}, \texttt{*}, \texttt{(},
\texttt{)}, \texttt{{[}}, and \texttt{\textbackslash{}} would be
interpreted as regex metacharacters, leading to either broken patterns
or security vulnerabilities (ReDoS). The equivalent inline syntax is
\texttt{\textbackslash{}Q..\textbackslash{}E} inside a regex. In stryke,
\texttt{quotemeta} handles the full Unicode range, escaping any
character that is not \texttt{{[}A-Za-z0-9\_{]}}. Use it liberally
whenever you splice user-provided strings into patterns.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $input = "file (1).txt"}
\NormalTok{my $safe = quotemeta $input}
\NormalTok{p $safe  \# file\textbackslash{} \textbackslash{}(1\textbackslash{})\textbackslash{}.txt}
\NormalTok{my $found = ("file (1).txt" =\textasciitilde{} /\^{}$safe$/)}
\NormalTok{p $found  \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trim}}{trim}}\label{trim}

\texttt{trim\ STRING} or \texttt{trim\ LIST} --- strip leading and
trailing ASCII whitespace.

When given a single string, \texttt{trim} 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 \texttt{tm}
alias is convenient in pipeline chains where brevity matters.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{" hello " |\textgreater{} tm |\textgreater{} p                  \# "hello"}
\NormalTok{@raw |\textgreater{} tm |\textgreater{} e p}
\NormalTok{slurp("data.csv") |\textgreater{} ln |\textgreater{} tm |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lines}}{lines}}\label{lines}

\texttt{lines\ STRING} / \texttt{ln\ STRING} --- split a string on
newline boundaries, returning a streaming iterator of lines.

Each line is yielded without the trailing newline character. When piped
from \texttt{slurp}, this gives you a lazy line-by-line view of a file
without loading all lines into memory at once. Both
\texttt{\textbackslash{}n} and
\texttt{\textbackslash{}r\textbackslash{}n} line endings are handled.
The \texttt{ln} alias keeps pipelines compact.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{slurp("data.txt") |\textgreater{} lines |\textgreater{} e p}
\NormalTok{my @rows = lines $multiline\_str}
\NormalTok{$body |\textgreater{} ln |\textgreater{} grep /TODO/ |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{words}}{words}}\label{words}

\texttt{words} (alias \texttt{wd}) splits a string on whitespace
boundaries and returns the resulting list of words. It handles leading,
trailing, and consecutive whitespace gracefully --- unlike a naive
\texttt{split\ /\ /}, it never produces empty strings. This is the
idiomatic way to tokenize a line of text in stryke, and the short alias
\texttt{wd} keeps pipelines compact. It is equivalent to
Perl\textquotesingle s
\texttt{split\ \textquotesingle{}\ \textquotesingle{}} behavior.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @w = wd "  hello   world  "}
\NormalTok{p @w       \# hello, world}
\NormalTok{my $line = "  foo  bar  baz  "}
\NormalTok{my $count = scalar wd $line}
\NormalTok{p $count   \# 3}
\NormalTok{rl("data.txt") |\textgreater{} map \{ scalar wd \_ \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chars}}{chars}}\label{chars}

\texttt{chars\ STRING} / \texttt{ch\ STRING} --- split a string into
individual characters, returning a streaming iterator.

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
\texttt{take}, \texttt{grep}, or \texttt{with\_index} without
materializing the full character array.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{"hello" |\textgreater{} chars |\textgreater{} e p               \# h e l l o}
\NormalTok{my @c = chars "abc"}
\NormalTok{"emoji: \textbackslash{}x\{1F600\}" |\textgreater{} ch |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snake\_case}}{snake\_case}}\label{snake_case}

\texttt{snake\_case} (alias \texttt{sc}) 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., \texttt{parseHTTPResponse} becomes
\texttt{parse\_http\_response}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sc "camelCase"          \# camel\_case}
\NormalTok{p sc "PascalCase"         \# pascal\_case}
\NormalTok{p sc "kebab{-}case"         \# kebab\_case}
\NormalTok{p sc "parseHTTPResponse"  \# parse\_http\_response}
\NormalTok{my @methods = qw(getUserName setEmailAddr)}
\NormalTok{@methods |\textgreater{} map sc |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{camel\_case}}{camel\_case}}\label{camel_case}

\texttt{camel\_case} (alias \texttt{cc}) 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cc "snake\_case"         \# snakeCase}
\NormalTok{p cc "kebab{-}case"         \# kebabCase}
\NormalTok{p cc "PascalCase"         \# pascalCase}
\NormalTok{p cc "hello world"        \# helloWorld}
\NormalTok{my @cols = qw(first\_name last\_name email\_addr)}
\NormalTok{@cols |\textgreater{} map cc |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kebab\_case}}{kebab\_case}}\label{kebab_case}

\texttt{kebab\_case} (alias \texttt{kc}) 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 \texttt{snake\_case}, it
intelligently handles acronyms and mixed-case input. The function treats
underscores, spaces, and case transitions as word boundaries.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p kc "camelCase"          \# camel{-}case}
\NormalTok{p kc "PascalCase"         \# pascal{-}case}
\NormalTok{p kc "snake\_case"         \# snake{-}case}
\NormalTok{p kc "parseHTTPResponse"  \# parse{-}http{-}response}
\NormalTok{my $slug = kc $title      \# URL{-}safe slug}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{study}}{study}}\label{study}

\texttt{study\ STRING} --- 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.

In classic Perl, \texttt{study} builds a linked list of character
positions so subsequent regex matches can skip impossible starting
points. In practice, modern regex engines (including
stryke\textquotesingle s Rust-based engine) already perform these
optimizations internally, so \texttt{study} 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
\texttt{study} when porting legacy scripts that call it; do not add it
to new stryke code expecting a performance benefit.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{study $text   \# no{-}op in stryke, kept for compatibility}
\NormalTok{my @hits = grep \{ /$pattern/ \} @lines}
\NormalTok{p scalar @hits}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pos}}{pos}}\label{pos}

\texttt{pos\ SCALAR} --- gets or sets the position where the next
\texttt{m//g} (global match) will start searching in the given string.
After a successful \texttt{m//g} match, \texttt{pos} returns the offset
just past the end of the match. You can assign to \texttt{pos(\$s)} to
manually reposition the search. If the last \texttt{m//g} failed,
\texttt{pos} resets to \texttt{undef}. This is essential for writing
lexers or tokenizers that consume a string incrementally with
\texttt{\textbackslash{}G}-anchored patterns. In stryke, \texttt{pos}
tracks per-scalar state just like Perl.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = "abcabc"}
\NormalTok{while ($s =\textasciitilde{} /a/g) \{ p pos($s) \}}
\NormalTok{\# 1 4}
\NormalTok{pos($s) = 0   \# reset to scan again}
\NormalTok{p pos($s)     \# 0}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-arrays-hashes}
\chapter{Arrays \& Hashes}\label{arrays-hashes}

20 topics

\section{\texorpdfstring{\texttt{push}}{push}}\label{push}

\texttt{push\ @array,\ LIST} --- 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\textquotesingle s
builtin. You can push scalars, lists, or even the result of a pipeline.
In stryke, \texttt{push} is O(1) amortized thanks to the underlying Rust
\texttt{Vec}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @q}
\NormalTok{push @q, 1:3}
\NormalTok{push @q, "four", "five"}
\NormalTok{p scalar @q   \# 5}
\NormalTok{@q |\textgreater{} e p     \# 1 2 3 four five}
\end{Highlighting}
\end{Shaded}

Returns the new element count, so
\texttt{my\ \$len\ =\ push\ @arr,\ \$val;} is valid.

\section{\texorpdfstring{\texttt{pop}}{pop}}\label{pop}

\texttt{pop\ @array} --- removes and returns the last element of an
array, or \texttt{undef} if the array is empty. This is the complement
of \texttt{push} and together they give you classic stack (LIFO)
semantics. In stryke the operation is O(1) because the underlying Rust
\texttt{Vec::pop} simply decrements the length. When called without an
argument inside a subroutine, \texttt{pop} operates on \texttt{@\_}; at
file scope it operates on \texttt{@ARGV}, matching standard Perl
behavior.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @stk = 1:5}
\NormalTok{my $top = pop @stk}
\NormalTok{p $top          \# 5}
\NormalTok{p scalar @stk   \# 4}
\NormalTok{@stk |\textgreater{} e p     \# 1 2 3 4}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shift}}{shift}}\label{shift}

\texttt{shift\ @array} --- removes and returns the first element of an
array, sliding all remaining elements down by one index. Like
\texttt{pop}, it returns \texttt{undef} on an empty array. Without an
explicit argument it defaults to \texttt{@\_} inside subroutines and
\texttt{@ARGV} at file scope. Because every element must be moved,
\texttt{shift} is O(n); if you only need LIFO access, prefer
\texttt{push}/\texttt{pop}. Use \texttt{shift} when processing argument
lists or implementing FIFO queues.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @args = @ARGV}
\NormalTok{my $cmd = shift @args}
\NormalTok{p $cmd}
\NormalTok{@args |\textgreater{} e p   \# remaining arguments}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unshift}}{unshift}}\label{unshift}

\texttt{unshift\ @array,\ LIST} --- prepends one or more elements to the
beginning of an array and returns the new length. It is the counterpart
of \texttt{push} for the front of the array. Like \texttt{shift}, 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, \texttt{unshift} is the idiomatic choice. You
can pass multiple values and they will appear in the same order they
were given.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @log = ("b", "c")}
\NormalTok{unshift @log, "a"}
\NormalTok{@log |\textgreater{} e p   \# a b c}
\NormalTok{my $len = unshift @log, "x", "y"}
\NormalTok{p $len        \# 5}
\NormalTok{@log |\textgreater{} e p   \# x y a b c}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{splice}}{splice}}\label{splice}

\texttt{splice\ @array,\ OFFSET\ {[},\ LENGTH\ {[},\ LIST{]}{]}} --- 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\textquotesingle s \texttt{Vec::splice} and
\texttt{Vec::drain}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 1:5}
\NormalTok{my @removed = splice @a, 1, 2, 8, 9}
\NormalTok{@a |\textgreater{} e p        \# 1 8 9 4 5}
\NormalTok{@removed |\textgreater{} e p  \# 2 3}
\NormalTok{splice @a, 2     \# remove from index 2 onward}
\NormalTok{@a |\textgreater{} e p        \# 1 8}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{splice\_last}}{splice\_last}}\label{splice_last}

\texttt{splice\_last\ @array,\ OFFSET\ {[},\ LENGTH\ {[},\ LIST{]}{]}}
--- same shape as \texttt{splice}, but returns the \textbf{last} removed
element instead of the full removed list (or \texttt{undef} if nothing
was removed). The stryke spelling of Perl\textquotesingle s
\texttt{scalar\ splice(@a,\ off,\ n)} for \texttt{-\/-no-interop} mode
where \texttt{scalar} is rejected at parse time. The array is still
mutated in place, exactly like \texttt{splice}. Aliases:
\texttt{splice1}, \texttt{spl\_last}. Desugars to
\texttt{tail(splice(...))} so any list-context property of
\texttt{splice} is preserved.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = 10:50:10}
\NormalTok{my $last = splice\_last @a, 1, 2   \# removes (20, 30), returns 30}
\NormalTok{@a |\textgreater{} e p                          \# 10 40 50}
\NormalTok{my $popped = splice\_last @b, 0, 0  \# removes nothing, returns undef}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{keys}}{keys}}\label{keys}

\texttt{keys\ \%hash} --- 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 \texttt{\$\#array}). In scalar context, \texttt{keys}
returns the number of keys. Calling \texttt{keys} resets the
\texttt{each} iterator on that hash, which is the standard way to
restart iteration. In stryke, this calls Rust\textquotesingle s
\texttt{HashMap::keys()} and collects into a \texttt{Vec}. For sorted
output, chain with \texttt{sort} via the pipe operator.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%env = (HOME =\textgreater{} "/root", USER =\textgreater{} "me")}
\NormalTok{keys(\%env) |\textgreater{} sort |\textgreater{} e p   \# HOME USER}
\NormalTok{p scalar keys \%env           \# 2}
\NormalTok{my @a = (10, 20, 30)}
\NormalTok{keys(@a) |\textgreater{} e p              \# 0 1 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{values}}{values}}\label{values}

\texttt{values\ \%hash} --- returns the list of all values in a hash in
no particular order (matching the order of \texttt{keys} 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
\texttt{keys}, calling \texttt{values} resets the \texttt{each}
iterator. In stryke this maps to Rust\textquotesingle s
\texttt{HashMap::values()}. Combine with \texttt{sum}, \texttt{sort}, or
pipeline operators for common aggregation patterns.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%scores = (alice =\textgreater{} 90, bob =\textgreater{} 85)}
\NormalTok{p sum(values \%scores)   \# 175}
\NormalTok{values(\%scores) |\textgreater{} sort \{ $\_1 \textless{}=\textgreater{} $\_0 \} |\textgreater{} e p   \# 90 85}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{each}}{each}}\label{each}

\texttt{each\ \%hash} --- 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
\texttt{keys} or \texttt{values} 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
\texttt{each}; that can cause skipped or duplicated entries. In stryke,
the iteration order is non-deterministic (Rust \texttt{HashMap} order).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%h = (a =\textgreater{} 1, b =\textgreater{} 2, c =\textgreater{} 3)}
\NormalTok{while (my ($k, $v) = each \%h) \{ p "$k=$v" \}}
\NormalTok{\# output order varies: a=1 b=2 c=3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delete}}{delete}}\label{delete}

\texttt{delete\ EXPR} --- removes a key-value pair from a hash or an
element from an array and returns the removed value (or \texttt{undef}
if it did not exist). For hashes this is the only way to truly remove a
key; assigning \texttt{undef} to \texttt{\$h\{key\}} leaves the key in
place. For arrays, \texttt{delete} sets the element to \texttt{undef}
but does not shift indices (use \texttt{splice} if you need to close the
gap). In stryke, hash deletion maps to Rust\textquotesingle s
\texttt{HashMap::remove}. You can delete multiple keys at once with a
hash slice: \texttt{delete\ @h\{@keys\}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%h = (x =\textgreater{} 1, y =\textgreater{} 2, z =\textgreater{} 3)}
\NormalTok{my $old = delete $h\{x\}}
\NormalTok{p $old   \# 1}
\NormalTok{p exists $h\{x\} ? "yes" : "no"   \# no}
\NormalTok{delete @h\{"y", "z"\}   \# delete multiple keys}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exists}}{exists}}\label{exists}

\texttt{exists\ EXPR} --- 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 \texttt{undef}. This is different from
\texttt{defined}: a key can exist but hold \texttt{undef}. Use
\texttt{exists} to check hash membership before accessing a value to
avoid autovivification side effects. In stryke, \texttt{exists} on a
hash compiles to Rust\textquotesingle s \texttt{HashMap::contains\_key},
and on an array it checks bounds. You can also use it with nested
structures: \texttt{exists\ \$h\{a\}\{b\}} only checks the final level.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%h = (a =\textgreater{} 1, b =\textgreater{} undef)}
\NormalTok{p exists $h\{b\} ? "yes" : "no"   \# yes (key present, value undef)}
\NormalTok{p exists $h\{c\} ? "yes" : "no"   \# no}
\NormalTok{my @a = (10, 20, 30)}
\NormalTok{p exists $a[5] ? "yes" : "no"   \# no}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scalar}}{scalar}}\label{scalar}

\texttt{scalar\ EXPR} --- forces the expression into scalar context. The
most common use is \texttt{scalar\ @array} to get the element count
instead of the list of elements. In stryke, scalar context on an array
returns its length as a Rust \texttt{usize}. You can also use
\texttt{scalar} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @items = ("a", "b", "c")}
\NormalTok{p scalar @items   \# 3}
\NormalTok{p "count: " . scalar @items   \# count: 3}
\NormalTok{my \%h = (x =\textgreater{} 1, y =\textgreater{} 2)}
\NormalTok{p scalar \%h       \# 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{defined}}{defined}}\label{defined}

\texttt{defined\ EXPR} --- returns true if the expression has a value
that is not \texttt{undef}. This is the canonical way to distinguish
between "no value" and "a value that happens to be false" (such as
\texttt{0}, \texttt{""}, or \texttt{"0"}). Use \texttt{defined} before
dereferencing optional values or checking return codes from functions
that return \texttt{undef} on failure. In stryke, \texttt{defined}
compiles to a Rust \texttt{Option::is\_some()} check internally. Note
that \texttt{defined} on an aggregate (hash or array) is deprecated in
Perl 5 and is a no-op in stryke.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $x = undef}
\NormalTok{p defined($x) ? "yes" : "no"   \# no}
\NormalTok{$x = 0}
\NormalTok{p defined($x) ? "yes" : "no"   \# yes}
\NormalTok{my $val = fn\_that\_may\_fail()}
\NormalTok{p $val if defined $val}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{undef}}{undef}}\label{undef}

\texttt{undef} --- the undefined value, representing the absence of a
value. As a function, \texttt{undef\ \$var} explicitly undefines a
variable, freeing any value it held. \texttt{undef} is falsy in boolean
context and triggers "use of uninitialized value" warnings under
\texttt{use\ warnings}. In stryke, \texttt{undef} maps to
Rust\textquotesingle s \texttt{None} in an \texttt{Option} type
internally. Use \texttt{undef} to reset variables, signal missing return
values, or clear hash entries without deleting the key.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $x = 42}
\NormalTok{undef $x}
\NormalTok{p defined($x) ? "def" : "undef"   \# undef}
\NormalTok{fn maybe \{ return undef if !@\_}
\NormalTok{    return $\_[0] \}}
\NormalTok{p defined(maybe()) ? "got" : "nothing"   \# nothing}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ref}}{ref}}\label{ref}

\texttt{ref\ EXPR} --- returns a string indicating the reference type of
the value, or an empty string if it is not a reference. Common return
values are \texttt{SCALAR}, \texttt{ARRAY}, \texttt{HASH},
\texttt{CODE}, \texttt{REF}, and \texttt{Regexp}. For blessed objects it
returns the class name. Use \texttt{ref} to dispatch on data type or
validate arguments in polymorphic functions. In stryke, \texttt{ref}
inspects the Rust enum variant of the underlying value. Note that
\texttt{ref} does not recurse; it only tells you the top-level type.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $r = [1, 2, 3]}
\NormalTok{p ref($r)       \# ARRAY}
\NormalTok{p ref(\textbackslash{}\%ENV)    \# HASH}
\NormalTok{p ref(\textbackslash{}\&main)   \# CODE}
\NormalTok{p ref(42)       \# (empty string)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bless}}{bless}}\label{bless}

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
\texttt{-\textgreater{}}. The second argument defaults to the current
package. This is the foundation of Perl\textquotesingle s object system.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn new($class, \%args) \{}
\NormalTok{    bless \{ \%args \}, $class}
\NormalTok{\}}
\NormalTok{my $obj = new("Dog", name =\textgreater{} "Rex", breed =\textgreater{} "Lab")}
\NormalTok{p ref($obj)          \# Dog}
\NormalTok{p $obj{-}\textgreater{}\{name\}       \# Rex}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tie}}{tie}}\label{tie}

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\textquotesingle s mechanism for transparent object-backed variables
--- tied hashes can be backed by a database, tied scalars can validate
on assignment, etc. Use \texttt{untie} to remove the binding.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{tie my \%db, \textquotesingle{}DB\_File\textquotesingle{}, \textquotesingle{}cache.db\textquotesingle{}}
\NormalTok{$db\{key\} = "value"         \# writes to disk}
\NormalTok{p $db\{key\}                  \# reads from disk}
\NormalTok{untie \%db}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prototype}}{prototype}}\label{prototype}

Return the prototype string of a named function, or \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p prototype("CORE::push")     \# \textbackslash{}@@}
\NormalTok{p prototype("CORE::map")      \# \&@}
\NormalTok{fn greet($name) \{ p "hi $name" \}}
\NormalTok{p prototype(\textbackslash{}\&greet)          \# undef (signatures, no proto)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wantarray}}{wantarray}}\label{wantarray}

\texttt{wantarray()} --- returns true if the current subroutine was
called in list context, false in scalar context, and \texttt{undef} in
void context. This lets a function adapt its return value to the
caller\textquotesingle s expectations. A common pattern is returning a
list in list context and a count or reference in scalar context. In
stryke, use \texttt{fn} to define subroutines and \texttt{wantarray()}
inside them just like in Perl. Note that \texttt{wantarray} only
reflects the immediate call site, not nested contexts.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn ctx \{ wantarray() ? "list" : "scalar" \}}
\NormalTok{my @r = ctx()}
\NormalTok{p $r[0]   \# list}
\NormalTok{my $r = ctx()}
\NormalTok{p $r      \# scalar}
\NormalTok{fn flexible \{ wantarray() ? (1, 2, 3) : 3 \}}
\NormalTok{my @all = flexible()}
\NormalTok{p scalar @all   \# 3}
\NormalTok{my $cnt = flexible()}
\NormalTok{p $cnt          \# 3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{caller}}{caller}}\label{caller}

\texttt{caller\ {[}LEVEL{]}} --- returns information about the calling
subroutine\textquotesingle s context. In list context it returns
\texttt{(package,\ filename,\ line)} 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, \texttt{caller} returns just the package name. In stryke,
\texttt{caller} works with \texttt{fn}-defined subroutines and
integrates with the runtime\textquotesingle s frame tracking. This is
invaluable for building custom error reporters or trace utilities.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn here \{}
\NormalTok{    my ($pkg, $f, $ln) = caller()}
\NormalTok{    p "$f:$ln"}
\NormalTok{\}}
\NormalTok{here()   \# prints current file:line}
\NormalTok{fn deep \{}
\NormalTok{    my ($pkg, $f, $ln) = caller(1)}
\NormalTok{    p "grandparent: $f:$ln"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-control-flow}
\chapter{Control Flow}\label{control-flow}

17 topics

\section{\texorpdfstring{\texttt{if}}{if}}\label{if}

The fundamental conditional construct. Evaluates its condition in
boolean context and executes the block if true. stryke supports both the
block form \texttt{if\ (COND)\ \{\ BODY\ \}} and the postfix form
\texttt{EXPR\ if\ COND}, which is idiomatic for single-statement guards.
The condition can be any expression --- numbers (0 is false), strings
(empty and \texttt{"0"} are false), undef (false), and references
(always true). Postfix \texttt{if} cannot have
\texttt{elsif}/\texttt{else} --- use the block form for multi-branch
logic.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $n = 42}
\NormalTok{if ($n \textgreater{} 0) \{ p "positive" \}}
\NormalTok{p "big" if $n \textgreater{} 10          \# postfix — clean one{-}liner}
\NormalTok{my $label = "even" if $n \% 2 == 0}
\NormalTok{p "got: $n" if defined $n   \# guard against undef}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elsif}}{elsif}}\label{elsif}

Chain additional conditions after an \texttt{if} block without nesting.
Each \texttt{elsif} 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 \texttt{elsif} branches. In stryke, prefer
\texttt{match} for complex multi-branch dispatch since it supports
pattern matching, destructuring, and guards --- but \texttt{elsif}
remains the right tool for simple linear condition chains. Note: it is
\texttt{elsif}, not \texttt{elseif} or \texttt{else\ if} --- the latter
is a syntax error.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn classify($n) \{}
\NormalTok{    if    ($n \textless{} 0)   \{ "negative" \}}
\NormalTok{    elsif ($n == 0)  \{ "zero" \}}
\NormalTok{    elsif ($n \textless{} 10)  \{ "small" \}}
\NormalTok{    elsif ($n \textless{} 100) \{ "medium" \}}
\NormalTok{    else             \{ "large" \}}
\NormalTok{\}}
\NormalTok{1:200 |\textgreater{} map classify |\textgreater{} frequencies |\textgreater{} dd}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{else}}{else}}\label{else}

The final fallback branch of an \texttt{if}/\texttt{elsif} chain,
executed when no preceding condition was true. Every \texttt{if} can
have at most one \texttt{else}, and it must come last. For ternary-style
expressions, use \texttt{COND\ ?\ A\ :\ B} instead of an
\texttt{if}/\texttt{else} block --- it composes better in
\texttt{\textbar{}\textgreater{}} pipes and assignments.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if ($n \% 2 == 0) \{ p "even" \}}
\NormalTok{else             \{ p "odd" \}}

\NormalTok{\# Ternary is often cleaner in pipes:}
\NormalTok{1:10 |\textgreater{} map \{ \_ \% 2 == 0 ? "even" : "odd" \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unless}}{unless}}\label{unless}

A negated conditional --- executes the block when the condition is
*false*. This reads more naturally than \texttt{if\ (!COND)} for guard
clauses and early returns. stryke supports both block and postfix forms.
Convention: use \texttt{unless} for simple negative guards; avoid
\texttt{unless} with complex compound conditions, as double-negatives
hurt readability. There is no \texttt{unlessif} --- use
\texttt{if}/\texttt{elsif} chains for multi-branch logic.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{unless ($ENV\{QUIET\}) \{ p "verbose output" \}}
\NormalTok{p "missing!" unless {-}e $path   \# postfix guard}
\NormalTok{die "no input" unless @ARGV}
\NormalTok{return unless defined $val    \# early return pattern}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{for}}{for}}\label{for}

Iterate over a list, binding each element to a loop variable (or
\texttt{\_} by default). \texttt{for} and \texttt{foreach} are
interchangeable keywords. The loop variable is automatically localized
and aliases the original element --- modifications to \texttt{\_} inside
the loop mutate the list in-place. In stryke, \texttt{for} loops work
with ranges, arrays, hash slices, and iterator results. For parallel
iteration, see \texttt{pfor}; for pipeline-style processing, prefer
\texttt{\textbar{}\textgreater{}\ e} or
\texttt{\textbar{}\textgreater{}\ map}. C-style
\texttt{for\ (INIT;\ COND;\ STEP)} is also supported.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{for my $f (glob "*.txt") \{ p $f \}}
\NormalTok{for (1:5) \{ p \_ * 2 \}            \# \_ is default}
\NormalTok{my @names = qw(alice bob carol)}
\NormalTok{for (@names) \{ \_ = uc \_ \}         \# mutates in{-}place}
\NormalTok{p join ", ", @names                 \# ALICE, BOB, CAROL}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{while}}{while}}\label{while}

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. \texttt{while} integrates naturally with the diamond operator
\texttt{\textless{}\textgreater{}} for reading filehandles. The loop
variable can be declared in the condition with \texttt{my}, scoping it
to the loop body. Postfix form is also supported:
\texttt{EXPR\ while\ COND;}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{while (my $line = \textless{}STDIN\textgreater{}) \{}
\NormalTok{    $line |\textgreater{} tm |\textgreater{} p             \# trim + print each line}
\NormalTok{\}}
\NormalTok{my $i = 0}
\NormalTok{while ($i \textless{} 5) \{ p $i++ \}    \# counted loop}
\NormalTok{while (1) \{ last if done() \}     \# infinite loop with break}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{until}}{until}}\label{until}

Loop that continues as long as its condition is *false* --- the logical
inverse of \texttt{while}. 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 \texttt{while}
with a negated condition if \texttt{until} makes the logic harder to
read.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $n = 1}
\NormalTok{until ($n \textgreater{} 1000) \{ $n *= 2 \}}
\NormalTok{p $n   \# 1024}

\NormalTok{my $tries = 0}
\NormalTok{until (connected()) \{}
\NormalTok{    $tries++}
\NormalTok{    sleep 1}
\NormalTok{\}}
\NormalTok{p "connected after $tries tries"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{do}}{do}}\label{do}

Execute a block and return its value, or execute a file. As a block,
\texttt{do\ \{\ ...\ \}} creates an expression scope --- the last
expression in the block is the return value, making it useful for
complex initializations. As a file operation, \texttt{do\ "file.pl"}
executes the file in the current scope and returns its last expression.
Unlike \texttt{require}, \texttt{do} does not cache and re-executes on
each call. \texttt{do\ \{\ ...\ \}\ while\ (COND)} creates a loop that
always runs at least once.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $val = do \{ my $x = 10}
\NormalTok{    $x ** 2 \}   \# 100}
\NormalTok{p $val}
\NormalTok{my $cfg = do "config.pl"               \# load config}
\NormalTok{\# do{-}while: body runs at least once}
\NormalTok{my $input}
\NormalTok{do \{ $input = readline(STDIN) |\textgreater{} tm \} while ($input eq "")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last}}{last}}\label{last}

Immediately exit the innermost enclosing loop (equivalent to
\texttt{break} in C/Rust). Execution continues after the loop.
\texttt{last\ LABEL} can target a labeled outer loop to break out of
nested loops. Works in \texttt{for}, \texttt{foreach}, \texttt{while},
\texttt{until}, and \texttt{do-while}. Does *not* work inside
\texttt{map}, \texttt{grep}, or \texttt{\textbar{}\textgreater{}}
pipeline stages --- use \texttt{take}, \texttt{first}, or
\texttt{take\_while} for early termination in functional contexts.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{for (1:1\_000\_000) \{}
\NormalTok{    last if \_ \textgreater{} 5}
\NormalTok{    p \_}
\NormalTok{\}   \# prints 1 2 3 4 5}

\NormalTok{OUTER: for my $i (1:10) \{}
\NormalTok{    for my $j (1:10) \{}
\NormalTok{        last OUTER if $i * $j \textgreater{} 50   \# break both loops}
\NormalTok{    \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

For pipeline early-exit:
\texttt{1:1000\ \textbar{}\textgreater{}\ take\_while\ \{\ \_\ \textless{}\ 50\ \}\ \textbar{}\textgreater{}\ e\ p}.

\section{\texorpdfstring{\texttt{next}}{next}}\label{next}

Skip the rest of the current loop iteration and jump to the next one.
The loop condition (for \texttt{while}/\texttt{until}) or the next
element (for \texttt{for}/\texttt{foreach}) is evaluated immediately.
Like \texttt{last}, \texttt{next} supports labeled loops with
\texttt{next\ LABEL} for skipping in nested loops. This is the primary
tool for filtering within imperative loops. In stryke, consider
\texttt{grep}/\texttt{filter} or
\texttt{\textbar{}\textgreater{}\ reject} for functional-style filtering
instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{for (1:10) \{}
\NormalTok{    next if \_ \% 2        \# skip odds}
\NormalTok{    p \_}
\NormalTok{\}   \# 2 4 6 8 10}

\NormalTok{for my $file (glob "*") \{}
\NormalTok{    next unless {-}f $file   \# skip non{-}files}
\NormalTok{    next if $file =\textasciitilde{} /\^{}\textbackslash{}./  \# skip hidden}
\NormalTok{    p $file}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{redo}}{redo}}\label{redo}

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, \texttt{redo} 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
\texttt{retry\ \{\ ...\ \}\ times\ =\textgreater{}\ N,\ backoff\ =\textgreater{}\ \textquotesingle{}exponential\textquotesingle{}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{for my $url (@urls) \{}
\NormalTok{    my $body = eval \{ fetch($url) \}}
\NormalTok{    if ($@) \{}
\NormalTok{        warn "retry $url: $@"}
\NormalTok{        sleep 1}
\NormalTok{        redo   \# try same URL again}
\NormalTok{    \}}
\NormalTok{    p length($body)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{continue}}{continue}}\label{continue}

A block attached to a \texttt{for}/\texttt{foreach}/\texttt{while} loop
that executes after each iteration, even when \texttt{next} is called.
Analogous to the increment expression in a C-style \texttt{for} loop.
The \texttt{continue} block does *not* run when \texttt{last} or
\texttt{redo} is used. Useful for unconditional per-iteration
bookkeeping like incrementing counters, logging progress, or flushing
buffers. Rarely used but fully supported in stryke.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $count = 0}
\NormalTok{for my $item (@work) \{}
\NormalTok{    next if $item{-}\textgreater{}\{skip\}}
\NormalTok{    process($item)}
\NormalTok{\} continue \{}
\NormalTok{    $count++}
\NormalTok{    p "processed $count so far" if $count \% 100 == 0}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{given}}{given}}\label{given}

A switch-like construct that evaluates an expression and dispatches to
\texttt{when} blocks via smartmatch semantics. The topic variable
\texttt{\_} is set to the \texttt{given} expression for the duration of
the block. Each \texttt{when} clause is tested in order; the first match
executes its block and control passes out of the \texttt{given}
(implicit break). A \texttt{default} block handles the no-match case. In
stryke, prefer the \texttt{match} keyword for new code --- it offers
pattern destructuring, typed patterns, array/hash shape matching, and
\texttt{if} guards that \texttt{given}/\texttt{when} cannot express.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{given ($cmd) \{}
\NormalTok{    when ("start")   \{ p "starting up" \}}
\NormalTok{    when ("stop")    \{ p "shutting down" \}}
\NormalTok{    when (/\^{}re/)     \{ p "restarting" \}}
\NormalTok{    default          \{ p "unknown: $cmd" \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

See \texttt{match} for stryke-native pattern matching with
destructuring.

\section{\texorpdfstring{\texttt{when}}{when}}\label{when}

A case clause inside a \texttt{given} block. The expression is matched
against the topic \texttt{\_} using smartmatch semantics: strings match
exactly, regexes match against \texttt{\_}, arrayrefs check membership,
coderefs are called with \texttt{\_} as argument, and numbers compare
numerically. When a \texttt{when} clause matches, its block executes and
control exits the enclosing \texttt{given} (implicit break). Multiple
\texttt{when} clauses are tried in order until one matches.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{given ($val) \{}
\NormalTok{    when (/\^{}\textbackslash{}d+$/)      \{ p "number" \}}
\NormalTok{    when (["a","b","c"]) \{ p "early letter" \}}
\NormalTok{    when (42)            \{ p "the answer" \}}
\NormalTok{    default              \{ p "something else" \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

In stryke, the \texttt{match} keyword provides more powerful pattern
matching.

\section{\texorpdfstring{\texttt{default}}{default}}\label{default}

The fallback clause in a \texttt{given} block, executed when no
\texttt{when} clause matched. Every \texttt{given} should have a
\texttt{default} to handle unexpected values, similar to \texttt{else}
in an \texttt{if} chain or the wildcard \texttt{\_} arm in stryke
\texttt{match}. If no \texttt{default} is present and nothing matches,
execution simply continues after the \texttt{given} block. In stryke
\texttt{match}, use \texttt{\_\ =\textgreater{}\ ...} for the default
arm instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{given ($exit\_code) \{}
\NormalTok{    when (0) \{ p "success" \}}
\NormalTok{    when (1) \{ p "general error" \}}
\NormalTok{    when (2) \{ p "misuse" \}}
\NormalTok{    default  \{ p "unknown exit code: $exit\_code" \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{return}}{return}}\label{return}

Return a value from a subroutine.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn pin\_val($v, $lo, $hi) \{}
\NormalTok{    return $lo if $v \textless{} $lo}
\NormalTok{    return $hi if $v \textgreater{} $hi}
\NormalTok{    $v}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{not}}{not}}\label{not}

Low-precedence logical negation --- returns true if the expression is
false, and false if it is true. Functionally identical to \texttt{!} but
binds looser than almost everything, so \texttt{not\ \$a\ ==\ \$b} is
\texttt{not(\$a\ ==\ \$b)} rather than \texttt{(!\$a)\ ==\ \$b}. Useful
for readable boolean conditions.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{if (not defined $val) \{}
\NormalTok{    p "val is undef"}
\NormalTok{\}}
\NormalTok{my @missing = grep \{ not {-}e \_ \} @files}
\NormalTok{@missing |\textgreater{} e p}
\NormalTok{p not 0    \# 1}
\NormalTok{p not 1    \# (empty string)}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-error-handling}
\chapter{Error Handling}\label{error-handling}

8 topics

\section{\texorpdfstring{\texttt{try}}{try}}\label{try}

Structured exception handling that cleanly separates the happy path from
error recovery. The \texttt{try} block runs the code; if it throws (via
\texttt{die}), execution jumps to the \texttt{catch} block with the
exception bound to the declared variable. An optional \texttt{finally}
block runs unconditionally afterward --- ideal for cleanup like closing
filehandles or releasing locks. Unlike \texttt{eval},
\texttt{try}/\texttt{catch} is a first-class statement with proper
scoping and no \texttt{\$@} pollution. In stryke, \texttt{try}
integrates with all exception types including string messages, hashrefs,
and objects.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{try \{}
\NormalTok{    my $data = fetch\_json($url)}
\NormalTok{    p $data{-}\textgreater{}\{name\}}
\NormalTok{\} catch ($e) \{}
\NormalTok{    warn "request failed: $e"}
\NormalTok{    return fallback()}
\NormalTok{\} finally \{}
\NormalTok{    log\_info("fetch attempt complete")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Prefer \texttt{try}/\texttt{catch} over \texttt{eval\ \{\ \}} for new
code --- it reads better and avoids \texttt{\$@} clobbering races.

\section{\texorpdfstring{\texttt{catch}}{catch}}\label{catch}

The error-handling clause that follows a \texttt{try} block. When the
\texttt{try} block throws an exception, execution transfers to
\texttt{catch} with the exception value bound to the declared variable
(e.g. \texttt{\$e}). 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 \texttt{ref} or \texttt{match} inside
the catch body. If the catch block itself throws, the exception
propagates upward (the \texttt{finally} block still runs first, if
present).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{try \{ die \{ code =\textgreater{} 404, msg =\textgreater{} "not found" \} \}}
\NormalTok{catch ($e) \{}
\NormalTok{    if (ref $e eq \textquotesingle{}HASH\textquotesingle{}) \{}
\NormalTok{        p "error $e{-}\textgreater{}\{code\}: $e{-}\textgreater{}\{msg\}"}
\NormalTok{    \} else \{}
\NormalTok{        p "caught: $e"}
\NormalTok{    \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{finally}}{finally}}\label{finally}

A cleanup block that runs after \texttt{try}/\texttt{catch} regardless
of whether an exception was thrown or not. This guarantees resource
cleanup even if the \texttt{try} block throws or the \texttt{catch}
block re-throws. The \texttt{finally} block cannot change the exception
or the return value --- it is strictly for side effects like closing
filehandles, releasing locks, or logging. If \texttt{finally} itself
throws, that exception replaces the original one (avoid throwing in
finally). \texttt{finally} is optional --- you can use
\texttt{try}/\texttt{catch} without it.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $fh}
\NormalTok{try \{}
\NormalTok{    open $fh, \textquotesingle{}\textless{}\textquotesingle{}, $path or die $!}
\NormalTok{    process(\textless{}$fh\textgreater{})}
\NormalTok{\} catch ($e) \{}
\NormalTok{    log\_error("failed: $e")}
\NormalTok{\} finally \{}
\NormalTok{    close $fh if $fh   \# always cleanup}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eval}}{eval}}\label{eval}

The classic Perl exception-catching mechanism.
\texttt{eval\ \{\ BLOCK\ \}} executes the block in an exception-trapping
context: if the block throws (via \texttt{die}), execution continues
after the \texttt{eval} with the error stored in \texttt{\$@}.
\texttt{eval\ "STRING"} compiles and executes Perl code at runtime ---
powerful but dangerous (code injection risk). In stryke, prefer
\texttt{try}/\texttt{catch} for exception handling as it avoids the
\texttt{\$@} clobbering pitfalls and reads more clearly. \texttt{eval}
remains useful for dynamic code evaluation and backward compatibility
with Perl 5 idioms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{eval \{ die "oops" \}}
\NormalTok{if ($@) \{ p "caught: $@" \}}

\NormalTok{\# Eval string — dynamic code execution}
\NormalTok{my $expr = "2 + 2"}
\NormalTok{my $result = eval $expr}
\NormalTok{p $result   \# 4}
\end{Highlighting}
\end{Shaded}

Caveat: \texttt{\$@} can be clobbered by intervening \texttt{eval}s or
destructors --- \texttt{try}/\texttt{catch} avoids this.

\section{\texorpdfstring{\texttt{die}}{die}}\label{die}

Raise an exception, immediately unwinding the call stack until caught by
\texttt{try}/\texttt{catch} or \texttt{eval}. 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, \texttt{die} works identically to Perl 5 and
integrates with \texttt{try}/\texttt{catch}, \texttt{eval}, and the
\texttt{\$@} mechanism. Convention: end die messages with
\texttt{\textbackslash{}n} to suppress the automatic "at FILE line LINE"
suffix, or omit it to get location info for debugging.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn divide($a, $b) \{}
\NormalTok{    die "division by zero\textbackslash{}n" unless $b}
\NormalTok{    $a / $b}
\NormalTok{\}}

\NormalTok{\# Structured error}
\NormalTok{die \{ code =\textgreater{} 400, msg =\textgreater{} "bad request", field =\textgreater{} "email" \}}

\NormalTok{\# With automatic location}
\NormalTok{die "something broke"   \# prints: something broke at script.pl line 5.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{warn}}{warn}}\label{warn}

Print a warning message to STDERR without terminating the program.
Behaves like \texttt{die} but only emits the message instead of throwing
an exception. If the message does not end with
\texttt{\textbackslash{}n}, Perl appends the current file and line
number. Warnings can be intercepted with \texttt{\$SIG\{\_\_WARN\_\_\}}
or suppressed with \texttt{no\ warnings}. In stryke, \texttt{warn} is
useful for non-fatal diagnostics; for structured logging, use
\texttt{log\_warn} instead.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{warn "file not found: $path" unless {-}e $path}
\NormalTok{warn "deprecated: use fetch\_json instead\textbackslash{}n"  \# no line number}

\NormalTok{\# Intercept warnings}
\NormalTok{local $SIG\{\_\_WARN\_\_\} = fn ($msg) \{ log\_warn($msg) \}}
\NormalTok{warn "redirected to logger"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{croak}}{croak}}\label{croak}

Die from the caller\textquotesingle s perspective --- the error message
reports the file and line of the *caller*, not the function that called
\texttt{croak}. This is the right choice for library/module functions
where the error is the caller\textquotesingle s fault (bad arguments,
misuse). Without \texttt{croak}, the user sees an error pointing at
library internals, which is unhelpful. In stryke, \texttt{croak} is
available as a builtin without \texttt{use\ Carp}. For debugging deep
call chains, use \texttt{confess} instead to get a full stack trace.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn parse($s) \{}
\NormalTok{    croak "parse: empty input" unless length $s}
\NormalTok{    croak "parse: not JSON" unless $s =\textasciitilde{} /\^{}[\{\textbackslash{}[]/}
\NormalTok{    json\_decode($s)}
\NormalTok{\}}

\NormalTok{\# Error will point at the call site, not inside parse()}
\NormalTok{my $data = parse("")   \# dies: "parse: empty input at caller.pl line 5"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{confess}}{confess}}\label{confess}

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 \texttt{die} or \texttt{croak} only show one frame. Each frame
includes the package, file, and line number. In stryke, \texttt{confess}
is available as a builtin without \texttt{use\ Carp}. Use
\texttt{confess} during development for maximum diagnostic info; switch
to \texttt{croak} in production-facing libraries where the trace would
confuse end users.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn validate($data) \{}
\NormalTok{    confess "missing required field \textquotesingle{}name\textquotesingle{}" unless $data{-}\textgreater{}\{name\}}
\NormalTok{\}}
\NormalTok{fn process($input) \{ validate($input) \}}
\NormalTok{fn main \{ process(\{\}) \}   \# full trace: main {-}\textgreater{} process {-}\textgreater{} validate}
\end{Highlighting}
\end{Shaded}

The trace output shows:
\texttt{missing\ required\ field\ \textquotesingle{}name\textquotesingle{}\ at\ script.pl\ line\ 2.\textbackslash{}n\textbackslash{}tmain::validate\ called\ at\ line\ 4\textbackslash{}n\textbackslash{}t...}.

\protect\phantomsection\label{ch-aop-advice}
\chapter{AOP / Advice}\label{aop-advice}

7 topics

\section{\texorpdfstring{\texttt{before}}{before}}\label{before}

\texttt{before\ "\textless{}glob\textgreater{}"\ \{\ ...\ \}} ---
register advice that runs *before* every call to a sub whose name
matches the glob pattern. Inside the body, \texttt{\$INTERCEPT\_NAME}
holds the called sub\textquotesingle s name and
\texttt{@INTERCEPT\_ARGS} holds the args.

The leading keyword only commits to advice parsing when followed by a
string literal, so \texttt{before(...)} as a normal sub call still
parses normally. Multiple \texttt{before} advices on the same name all
fire in registration order. The advice cannot suppress the call (use
\texttt{around} for that) and its return value is discarded.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{before "fetch" \{ warn "calling fetch with @INTERCEPT\_ARGS" \}}
\NormalTok{before "log\_*" \{ $log\_count++ \}     \# glob: any sub starting with log\_}
\NormalTok{before "*"      \{ trace($INTERCEPT\_NAME) \}   \# every sub call}
\end{Highlighting}
\end{Shaded}

Bodies are lowered to bytecode and dispatched through the VM
(\texttt{run\_block\_region}), so \texttt{our\ \$x} and other
compile-time name resolutions work the same inside advice as outside it.
The body\textquotesingle s final statement must be an expression (same
constraint as \texttt{map\ \{\ \}} block lowering); a literal
\texttt{for}/\texttt{while}/\texttt{if} block or a literal
\texttt{return} will be rejected at firing time.

\section{\texorpdfstring{\texttt{after}}{after}}\label{after}

\texttt{after\ "\textless{}glob\textgreater{}"\ \{\ ...\ \}} ---
register advice that runs *after* every call to a sub whose name matches
the glob pattern. The body sees the call\textquotesingle s return in
\texttt{\$INTERCEPT\_RESULT}, the wall-clock duration in
\texttt{\$INTERCEPT\_MS} (millis, float) and \texttt{\$INTERCEPT\_US}
(micros, integer), the called name in \texttt{\$INTERCEPT\_NAME}, and
the args in \texttt{@INTERCEPT\_ARGS}.

Multiple \texttt{after} advices on the same name all fire in
registration order. The advice\textquotesingle s return value is
discarded --- the call\textquotesingle s return is whatever the original
sub (or a matching \texttt{around}) produced.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{after "fetch" \{ warn "fetch returned $INTERCEPT\_RESULT in $\{INTERCEPT\_MS\}ms" \}}
\NormalTok{after "*"     \{ log\_call($INTERCEPT\_NAME, $INTERCEPT\_US) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{around}}{around}}\label{around}

\texttt{around\ "\textless{}glob\textgreater{}"\ \{\ ...\ \}} ---
register advice that *wraps* every call to a sub whose name matches the
glob pattern. Use \texttt{proceed()} to invoke the original; the around
block\textquotesingle s evaluated value is the call\textquotesingle s
return (AspectJ-style).

The first matching \texttt{around} on a given name wraps; later
\texttt{around} matches are skipped (mirrors zshrs
\texttt{run\_intercepts}). If \texttt{proceed()} is not called, the
original sub never runs and the around block\textquotesingle s value
replaces it. The block can transform (\texttt{proceed()\ +\ 100}),
forward (just \texttt{proceed()}), or replace (omit \texttt{proceed()}
and emit a value).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{around "expensive" \{}
\NormalTok{    my $cached = cache\_get($INTERCEPT\_ARGS[0])}
\NormalTok{    return $cached if defined $cached}
\NormalTok{    my $r = proceed()}
\NormalTok{    cache\_put($INTERCEPT\_ARGS[0], $r)}
\NormalTok{    $r}
\NormalTok{\}}

\NormalTok{around "flaky" \{ my $r = eval \{ proceed() \}; $@ ? retry\_default() : $r \}}
\end{Highlighting}
\end{Shaded}

Recursion guard: calling the advised sub from inside its own advice runs
the original directly without re-firing advice --- no infinite loop.

\section{\texorpdfstring{\texttt{proceed}}{proceed}}\label{proceed}

\texttt{proceed()} --- invoke the original sub with the saved args from
inside an \texttt{around} advice block. Returns the
original\textquotesingle s value. Calling \texttt{proceed} outside an
\texttt{around} block is a runtime error.

The re-entrancy guard ensures \texttt{proceed} runs the original
directly without re-firing any matching \texttt{around} advice for the
same name, so transformation chains can\textquotesingle t infinite-loop.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{around "target" \{}
\NormalTok{    my $r = proceed()}
\NormalTok{    $r * 2     \# double whatever target returned}
\NormalTok{\}}

\NormalTok{around "target" \{ proceed() // "default" \}   \# forward, with fallback}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intercept\_list}}{intercept\_list}}\label{intercept_list}

\texttt{intercept\_list()} --- return the registered AOP advice as an
array of \texttt{{[}id,\ kind,\ pattern{]}} triples (each element is an
arrayref).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{before "foo" \{ ... \}}
\NormalTok{after  "bar*" \{ ... \}}
\NormalTok{for my $row (intercept\_list()) \{}
\NormalTok{    my ($id, $kind, $pat) = @$row}
\NormalTok{    p "id=$id kind=$kind pattern=$pat"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intercept\_remove}}{intercept\_remove}}\label{intercept_remove}

\texttt{intercept\_remove(\$id)} --- remove a single AOP advice by its
id (from \texttt{intercept\_list}). Returns the count removed (0 or 1).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{before "foo" \{ ... \}}
\NormalTok{my ($id, $kind, $pat) = @\{ (intercept\_list())[0] \}}
\NormalTok{intercept\_remove($id)}
\NormalTok{p scalar intercept\_list()   \# 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intercept\_clear}}{intercept\_clear}}\label{intercept_clear}

\texttt{intercept\_clear()} --- drop all registered AOP advice. Returns
the count cleared.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{before "a" \{ ... \}}
\NormalTok{after  "b" \{ ... \}}
\NormalTok{p intercept\_clear()         \# 2}
\NormalTok{p scalar intercept\_list()   \# 0}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-declarations}
\chapter{Declarations}\label{declarations}

10 topics

\section{\texorpdfstring{\texttt{my}}{my}}\label{my}

Declare a lexically scoped variable visible only within the enclosing
block or file. \texttt{my} is the workhorse of Perl variable
declarations --- use it for scalars (\texttt{\$}), arrays (\texttt{@}),
and hashes (\texttt{\%}). Variables declared with \texttt{my} are
invisible outside their scope, which prevents accidental cross-scope
mutation. In stryke, \texttt{my} variables participate in pipe chains
and can be destructured in list context. Uninitialized \texttt{my}
variables default to \texttt{undef}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $name = "world"}
\NormalTok{my @nums = 1:5}
\NormalTok{my \%cfg = (debug =\textgreater{} 1, verbose =\textgreater{} 0)}
\NormalTok{p "hello $name"}
\NormalTok{@nums |\textgreater{} grep \_ \textgreater{} 2 |\textgreater{} e p$1}

\NormalTok{Use \textasciigrave{}my\textasciigrave{} everywhere unless you specifically need \textasciigrave{}our\textasciigrave{} (package global), \textasciigrave{}local\textasciigrave{} (dynamic scope), or \textasciigrave{}state\textasciigrave{} (persistent).}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{our}}{our}}\label{our}

Declare a package-global variable accessible as a lexical alias in the
current scope. Unlike \texttt{my}, \texttt{our} variables are visible
across the entire package and can be accessed from other packages via
their fully qualified name (e.g. \texttt{\$Counter::total}). Useful for
package-level configuration, shared counters, or variables that need to
survive across file boundaries.

In stryke, \texttt{our} variables are NOT mutex-protected.
\textbf{Mutating an \texttt{our} variable from inside
\texttt{fan}/\texttt{pmap}/\texttt{pfor} is rejected at runtime} with a
directive to use \texttt{oursync} (the package-global counterpart of
\texttt{mysync} --- same \texttt{Arc\textless{}Mutex\textgreater{}}
backing, keyed by \texttt{Pkg::x}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{package Counter}
\NormalTok{our $total = 0           \# serial use only}
\NormalTok{fn bump \{ $total++ \}}
\NormalTok{package main}
\NormalTok{Counter::bump() for 1:5}
\NormalTok{p $Counter::total        \# 5}

\NormalTok{\# For parallel mutation, use oursync:}
\NormalTok{package C}
\NormalTok{oursync $shared = 0}
\NormalTok{fn bump \{ $shared++ \}}
\NormalTok{package main}
\NormalTok{fan 10000 \{ C::bump() \}   \# always exactly 10000}
\end{Highlighting}
\end{Shaded}

Prefer \texttt{my} for local state; \texttt{our} for cross-package
read-mostly globals; \texttt{oursync} for cross-package mutation under
parallelism.

\section{\texorpdfstring{\texttt{local}}{local}}\label{local}

Temporarily override a global variable\textquotesingle 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\textquotesingle s special variables (like \texttt{\$/},
\texttt{\$\textbackslash{}}, \texttt{\$,}) without permanently altering
global state. Unlike \texttt{my} which creates a new variable,
\texttt{local} saves and restores an existing global. In stryke,
\texttt{local} works with all special variables and respects the same
restoration semantics during exception unwinding.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{local $/ = undef       \# slurp mode}
\NormalTok{open my $fh, \textquotesingle{}\textless{}\textquotesingle{}, \textquotesingle{}data.txt\textquotesingle{} or die $!}
\NormalTok{my $body = \textless{}$fh\textgreater{}       \# reads entire file}
\NormalTok{close $fh}
\NormalTok{\# $/ restored to "\textbackslash{}n" when scope exits}
\end{Highlighting}
\end{Shaded}

Common patterns: \texttt{local\ \$/\ =\ undef} (slurp),
\texttt{local\ \$,\ =\ ","} (join print args), \texttt{local\ \%ENV}
(temporary env).

\section{\texorpdfstring{\texttt{state}}{state}}\label{state}

Declare a persistent lexical variable that retains its value across
calls to the enclosing subroutine. Unlike \texttt{my}, which
reinitializes on each call, \texttt{state} 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, \texttt{state} variables are per-thread when used
inside \texttt{\textasciitilde{}\textgreater{}\ \{\ \}} or \texttt{fan}
blocks; they are not shared across workers.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{fn ctr \{}
\NormalTok{    state $n = 0}
\NormalTok{    ++$n}
\NormalTok{\}}
\NormalTok{p ctr() for 1:5   \# 1 2 3 4 5}
\NormalTok{fn cache\_lookup($x) \{}
\NormalTok{    state \%cache}
\NormalTok{    $cache\{$x\} //= expensive($x)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Requires
\texttt{use\ feature\ \textquotesingle{}state\textquotesingle{}} in
standard Perl, but is always available in stryke.

\section{\texorpdfstring{\texttt{package}}{package}}\label{package}

Set the current package namespace for all subsequent declarations.
Package names are conventionally \texttt{CamelCase} with \texttt{::}
separators (e.g. \texttt{Math::Utils}). All unqualified function and
\texttt{our} 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
\texttt{struct} or \texttt{bless} for OOP). Switching packages mid-file
is allowed but discouraged; prefer one package per file.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{package Math::Utils}
\NormalTok{fn calc\_fact($n) \{ $n \textless{}= 1 ? 1 : $n * calc\_fact($n {-} 1) \}}
\NormalTok{fn calc\_fib($n) \{ $n \textless{} 2 ? $n : calc\_fib($n {-} 1) + calc\_fib($n {-} 2) \}}
\NormalTok{package main}
\NormalTok{p Math::Utils::calc\_fact(10)   \# 3628800}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{use}}{use}}\label{use}

Load and import a user module at compile time:
\texttt{use\ Module\ qw(func);}. Stryke list utilities (\texttt{sum},
\texttt{max}, \texttt{uniq}, \texttt{reduce}, \ldots), error helpers
(\texttt{croak}, \texttt{confess}, \texttt{carp}), and serialization
(\texttt{json\_encode}, \texttt{json\_decode}, \texttt{ddump}) are all
native bare-name builtins --- no import needed.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{use My::Project::Helpers qw(normalize\_path canonicalize)}

\NormalTok{my @vals = 1:10}
\NormalTok{p sum(@vals)   \# 55}
\NormalTok{p max(@vals)   \# 10}
\NormalTok{p normalize\_path("/tmp/../etc")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{no}}{no}}\label{no}

Unimport a module or pragma:
\texttt{no\ strict\ \textquotesingle{}refs\textquotesingle{};}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{no warnings \textquotesingle{}experimental\textquotesingle{}}
\NormalTok{given ($x) \{ when (1) \{ p "one" \} \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{require}}{require}}\label{require}

Load a user module at runtime: \texttt{require\ Module;}. JSON / YAML /
TOML decoding is built in (\texttt{json\_decode}, \texttt{yaml\_decode},
\texttt{toml\_decode}) --- no module load needed.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{require My::Plugin::Loader}
\NormalTok{my $loader = My::Plugin::Loader::init()}
\NormalTok{p $loader{-}\textgreater{}status}

\NormalTok{\# Built{-}in: no require needed}
\NormalTok{my $data = json\_decode($text)}
\NormalTok{p $data{-}\textgreater{}\{name\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{BEGIN}}{BEGIN}}\label{begin}

\texttt{BEGIN\ \{\ \}} --- runs at compile time, before the rest of the
program.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{BEGIN \{ p "compiling..." \}}
\NormalTok{p "running"}
\NormalTok{\# output: compiling... then running}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{END}}{END}}\label{end}

\texttt{END\ \{\ \}} --- runs after the program finishes (or on exit).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{END \{ p "cleanup done" \}}
\NormalTok{p "main work"}
\NormalTok{\# output: main work then cleanup done}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-cluster-distributed}
\chapter{Cluster / Distributed}\label{cluster-distributed}

4 topics

\section{\texorpdfstring{\texttt{cluster}}{cluster}}\label{cluster}

\texttt{cluster({[}"host1:N",\ "host2:M",\ ...{]})} --- build an
SSH-backed worker pool for distributing stryke workloads across multiple
machines.

Each entry in the list is a hostname (or \texttt{user@host}) 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 \texttt{stryke\ -\/-remote-worker} processes,
and manages a work-stealing scheduler across the entire cluster. The
cluster object is then passed to distributed primitives like
\texttt{pmap\_on} and \texttt{pflat\_map\_on}. Workers must have
\texttt{stryke} installed and accessible on \texttt{\$PATH}. If a host
becomes unreachable mid-computation, its in-flight tasks are
automatically re-queued to surviving hosts.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cl = cluster(["server1:8", "server2:4", "gpu{-}box:16"])}
\NormalTok{my @results = pmap\_on $cl, \{ heavy\_compute \} @jobs}

\NormalTok{\# Single{-}machine cluster for testing:}
\NormalTok{my $local = cluster(["localhost:4"])}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pmap\_on}}{pmap\_on}}\label{pmap_on}

\texttt{pmap\_on\ \$cluster,\ \{\ BLOCK\ \}\ @list} --- distributed
parallel map that fans work across a \texttt{cluster} of remote
machines.

Elements from \texttt{@list} are serialized, shipped to remote
\texttt{stryke\ -\/-remote-worker} 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
\texttt{pmap}: same interface, same order guarantee, but the thread pool
spans multiple hosts instead of local cores. Use this when a single
machine\textquotesingle 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cl = cluster(["host1:8", "host2:8"])}
\NormalTok{my @hashes = pmap\_on $cl, \{ sha256(slurp) \} @file\_paths}
\NormalTok{my @results = pmap\_on $cl, \{ fetch("https://api.example.com/$\_") \} 1:10\_000}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pflat\_map\_on}}{pflat\_map\_on}}\label{pflat_map_on}

Distributed parallel flat-map over \texttt{cluster}.

\section{\texorpdfstring{\texttt{ssh}}{ssh}}\label{ssh}

\texttt{ssh(\$host,\ \$command)} --- execute a shell command on a remote
host via SSH and return its stdout as a string.

This is a simple synchronous wrapper around an SSH invocation. The
command is run in the remote user\textquotesingle 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
\texttt{cluster} + \texttt{pmap\_on} which manages connection pooling
and parallelism automatically. \texttt{ssh} is best for one-off
administrative commands, health checks, or bootstrapping a remote
environment before building a cluster.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $uptime = ssh("server1", "uptime")}
\NormalTok{p ssh("deploy@prod", "cat /etc/hostname")}
\NormalTok{my $free = ssh("gpu{-}box", "nvidia{-}smi {-}{-}query{-}gpu=memory.free {-}{-}format=csv,noheader")}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-datetime}
\chapter{Datetime}\label{datetime}

15 topics

\section{\texorpdfstring{\texttt{datetime\_utc}}{datetime\_utc}}\label{datetime_utc}

Return the current UTC date and time as an ISO 8601 string (e.g.
\texttt{2026-04-15T12:30:00Z}). This is the simplest way to get a
portable, unambiguous timestamp for logging, file naming, or
serialization. The returned string always ends with \texttt{Z}
indicating UTC, so there is no timezone ambiguity.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $now = datetime\_utc()}
\NormalTok{p $now                          \# 2026{-}04{-}15T12:30:00Z}
\NormalTok{af("audit.log", "$now: started\textbackslash{}n")}
\NormalTok{my \%event = (ts =\textgreater{} datetime\_utc(), action =\textgreater{} "deploy")}
\NormalTok{wj("event.json", \textbackslash{}\%event)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_from\_epoch}}{datetime\_from\_epoch}}\label{datetime_from_epoch}

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 \texttt{time()}, file modification times, or external APIs
and need a human-readable representation. Fractional seconds are
truncated.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ts = 1700000000}
\NormalTok{p datetime\_from\_epoch($ts)       \# 2023{-}11{-}14T22:13:20Z}
\NormalTok{my $born = datetime\_from\_epoch(0)}
\NormalTok{p $born                          \# 1970{-}01{-}01T00:00:00Z}
\NormalTok{my @epochs = (1e9, 1.5e9, 2e9)}
\NormalTok{@epochs |\textgreater{} e \{ p datetime\_from\_epoch \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_strftime}}{datetime\_strftime}}\label{datetime_strftime}

Format an epoch timestamp using a \texttt{strftime}-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: \texttt{\%Y} (4-digit year), \texttt{\%m} (month),
\texttt{\%d} (day), \texttt{\%H} (hour), \texttt{\%M} (minute),
\texttt{\%S} (second), \texttt{\%A} (weekday name), and more.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $t = time()}
\NormalTok{p datetime\_strftime("\%Y{-}\%m{-}\%d", $t)        \# 2026{-}04{-}15}
\NormalTok{p datetime\_strftime("\%H:\%M:\%S", $t)        \# 14:23:07}
\NormalTok{p datetime\_strftime("\%A, \%B \%d", $t)       \# Wednesday, April 15}
\NormalTok{my $log\_ts = datetime\_strftime("\%Y\%m\%d\_\%H\%M\%S", $t)}
\NormalTok{to\_file("backup\_$log\_ts.sql", $data)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_now\_tz}}{datetime\_now\_tz}}\label{datetime_now_tz}

Return the current date and time in a specified IANA timezone as a
formatted string. Pass a timezone name like \texttt{America/New\_York},
\texttt{Europe/London}, or \texttt{Asia/Tokyo}. This avoids manual
UTC-offset arithmetic and handles daylight saving transitions correctly.
Dies if the timezone name is not recognized.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p datetime\_now\_tz("America/New\_York")    \# 2026{-}04{-}15 08:30:00 EDT}
\NormalTok{p datetime\_now\_tz("Asia/Tokyo")           \# 2026{-}04{-}15 21:30:00 JST}
\NormalTok{p datetime\_now\_tz("UTC")                  \# same as datetime\_utc}
\NormalTok{my @offices = ("US/Pacific", "Europe/Berlin", "Asia/Kolkata")}
\NormalTok{@offices |\textgreater{} e \{ p "$\_: " . datetime\_now\_tz \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_format\_tz}}{datetime\_format\_tz}}\label{datetime_format_tz}

Format an epoch timestamp in a specific IANA timezone, combining the
capabilities of \texttt{datetime\_strftime} and
\texttt{datetime\_now\_tz}. This lets you render a historical or future
timestamp as it would appear on the wall clock in any timezone. Handles
DST transitions automatically.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $epoch = 1700000000}
\NormalTok{p datetime\_format\_tz($epoch, "America/Chicago")}
\NormalTok{\# 2023{-}11{-}14 16:13:20 CST}
\NormalTok{p datetime\_format\_tz($epoch, "Europe/London")}
\NormalTok{\# 2023{-}11{-}14 22:13:20 GMT}
\NormalTok{p datetime\_format\_tz(time(), "Australia/Sydney")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_parse\_local}}{datetime\_parse\_local}}\label{datetime_parse_local}

Parse a local datetime string (without timezone info) into a Unix epoch
timestamp, interpreting it in the system\textquotesingle s local
timezone. Accepts common formats like \texttt{2026-04-15\ 14:30:00} or
\texttt{2026-04-15T14:30:00}. Dies if the string cannot be parsed. This
is the inverse of formatting with \texttt{localtime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $epoch = datetime\_parse\_local("2026{-}04{-}15 14:30:00")}
\NormalTok{p $epoch                          \# Unix timestamp}
\NormalTok{p datetime\_from\_epoch($epoch)     \# back to ISO 8601}
\NormalTok{my $midnight = datetime\_parse\_local("2026{-}01{-}01 00:00:00")}
\NormalTok{p time() {-} $midnight              \# seconds since New Year}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_parse\_rfc3339}}{datetime\_parse\_rfc3339}}\label{datetime_parse_rfc3339}

Parse an RFC 3339 / ISO 8601 datetime string (with timezone offset or
\texttt{Z} suffix) into a Unix epoch timestamp. This is the standard
format used by JSON APIs, RSS feeds, and git timestamps. Accepts strings
like \texttt{2026-04-15T14:30:00Z} or
\texttt{2026-04-15T14:30:00+05:30}. Dies on malformed input.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $epoch = datetime\_parse\_rfc3339("2026{-}04{-}15T12:00:00Z")}
\NormalTok{p $epoch}
\NormalTok{my $with\_tz = datetime\_parse\_rfc3339("2026{-}04{-}15T08:00:00{-}04:00")}
\NormalTok{p $epoch == $with\_tz              \# 1 (same instant)}
\NormalTok{\# parse API response timestamps}
\NormalTok{my $created = $response{-}\textgreater{}\{created\_at\}}
\NormalTok{my $age = time() {-} datetime\_parse\_rfc3339($created)}
\NormalTok{p "created $\{age\}s ago"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datetime\_add\_seconds}}{datetime\_add\_seconds}}\label{datetime_add_seconds}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $now = datetime\_utc()}
\NormalTok{my $later = datetime\_add\_seconds($now, 3600)     \# +1 hour}
\NormalTok{p $later}
\NormalTok{my $yesterday = datetime\_add\_seconds($now, {-}86400) \# {-}1 day}
\NormalTok{p $yesterday}
\NormalTok{my $deadline = datetime\_add\_seconds($now, 7 * 86400) \# +1 week}
\NormalTok{p "due by $deadline"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elapsed}}{elapsed}}\label{elapsed}

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 \texttt{el} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $t0 = el()}
\NormalTok{my @sorted = sort @big\_array}
\NormalTok{my $dur = el() {-} $t0}
\NormalTok{p "sort took $\{dur\}s"}
\NormalTok{\# progress logging}
\NormalTok{1:100 |\textgreater{} e \{ do\_work}
\NormalTok{    log\_info("step $\_ at " . el() . "s") \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{time}}{time}}\label{time}

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
\texttt{elapsed}/\texttt{el} instead since \texttt{time} can jump if the
system clock is adjusted.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $start = time()}
\NormalTok{sleep(2)}
\NormalTok{p time() {-} $start   \# \textasciitilde{}2}
\NormalTok{my $ts = time()}
\NormalTok{wj("stamp.json", \{ created =\textgreater{} $ts \})}
\NormalTok{p datetime\_from\_epoch($ts)  \# human{-}readable form}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{times}}{times}}\label{times}

Return the accumulated CPU times for the process as a four-element list:
\texttt{(\$user,\ \$system,\ \$child\_user,\ \$child\_system)}. 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($u, $s, $cu, $cs) = times()}
\NormalTok{p "user=$\{u\}s sys=$\{s\}s"}
\NormalTok{\# after heavy computation}
\NormalTok{my ($u2, $s2) = times()}
\NormalTok{p "used " . ($u2 {-} $u) . "s of CPU"}
\NormalTok{p "total CPU: " . ($u2 + $s2) . "s"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{localtime}}{localtime}}\label{localtime}

Convert a Unix epoch timestamp to a nine-element list of broken-down
local time components:
\texttt{(\$sec,\ \$min,\ \$hour,\ \$mday,\ \$mon,\ \$year,\ \$wday,\ \$yday,\ \$isdst)}.
Follows the Perl convention where \texttt{\$mon} is 0-based (January=0)
and \texttt{\$year} is years since 1900. When called without arguments,
uses the current time. Use \texttt{gmtime} for the UTC equivalent.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @t = localtime(time())}
\NormalTok{p "$t[2]:$t[1]:$t[0]"                 \# HH:MM:SS}
\NormalTok{my $year = $t[5] + 1900}
\NormalTok{my $mon  = $t[4] + 1}
\NormalTok{p "$year{-}$mon{-}$t[3]"                   \# YYYY{-}M{-}D}
\NormalTok{my @days = qw(Sun Mon Tue Wed Thu Fri Sat)}
\NormalTok{p $days[$t[6]]                          \# day of week}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gmtime}}{gmtime}}\label{gmtime}

Convert a Unix epoch timestamp to a nine-element list of broken-down UTC
time components, identical in structure to \texttt{localtime} but always
in the UTC timezone. The fields are
\texttt{(\$sec,\ \$min,\ \$hour,\ \$mday,\ \$mon,\ \$year,\ \$wday,\ \$yday,\ \$isdst)}
where \texttt{\$isdst} is always 0. When called without arguments, uses
the current time.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @utc = gmtime(time())}
\NormalTok{my $year = $utc[5] + 1900}
\NormalTok{my $mon  = $utc[4] + 1}
\NormalTok{p sprintf("\%04d{-}\%02d{-}\%02dT\%02d:\%02d:\%02dZ",}
\NormalTok{    $year, $mon, @utc[3,2,1,0])}
\NormalTok{\# compare local vs UTC}
\NormalTok{my @loc = localtime(time())}
\NormalTok{p "UTC hour=$utc[2] local hour=$loc[2]"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sleep}}{sleep}}\label{sleep}

Pause execution for the specified number of seconds. Accepts both
integer and fractional values for sub-second sleeps (e.g.
\texttt{sleep\ 0.1} 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).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p "waiting..."}
\NormalTok{sleep(2)}
\NormalTok{p "done"}
\NormalTok{\# polling loop}
\NormalTok{while (!{-}e "done.flag") \{}
\NormalTok{    sleep(0.5)}
\NormalTok{\}}
\NormalTok{\# rate limiting}
\NormalTok{my @urls = @targets}
\NormalTok{@urls |\textgreater{} e \{ fetch}
\NormalTok{    sleep(0.1) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alarm}}{alarm}}\label{alarm}

Schedule a \texttt{SIGALRM} signal to be delivered to the process after
the specified number of seconds. Calling \texttt{alarm(0)} 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 \texttt{eval}
and \texttt{\$SIG\{ALRM\}} to implement timeouts around potentially
hanging operations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{eval \{}
\NormalTok{    local $SIG\{ALRM\} = fn \{ die "timeout\textbackslash{}n" \}}
\NormalTok{    alarm(5)           \# 5 second deadline}
\NormalTok{    my $data = slow\_network\_call()}
\NormalTok{    alarm(0)           \# cancel on success}
\NormalTok{\}}
\NormalTok{if ($@ =\textasciitilde{} /timeout/) \{}
\NormalTok{    log\_error("operation timed out")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-math}
\chapter{Math}\label{math}

13 topics

\section{\texorpdfstring{\texttt{abs}}{abs}}\label{abs}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p abs({-}42)       \# 42}
\NormalTok{p abs(3.14)      \# 3.14}
\NormalTok{my $diff = abs($a {-} $b)}
\NormalTok{p "distance: $diff"}
\NormalTok{1:5 |\textgreater{} map \{ \_ {-} 3 \} |\textgreater{} map abs |\textgreater{} e p  \# 2 1 0 1 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{int}}{int}}\label{int}

Truncate a floating-point number toward zero, discarding the fractional
part. This is not rounding --- \texttt{int(1.9)} is \texttt{1} and
\texttt{int(-1.9)} is \texttt{-1}. Use \texttt{sprintf("\%.0f",\ \$n)}
or \texttt{POSIX::round} for proper rounding. Commonly paired with
\texttt{rand} to generate random integers.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p int(3.7)       \# 3}
\NormalTok{p int({-}3.7)      \# {-}3}
\NormalTok{p int(rand(6)) + 1  \# dice roll 1:6}
\NormalTok{1:10 |\textgreater{} map \{ \_ / 3 \} |\textgreater{} map int |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sqrt}}{sqrt}}\label{sqrt}

Return the square root of a non-negative number. Dies if the argument is
negative --- use \texttt{abs} first or check the sign. For the inverse
operation, use \texttt{squared}/\texttt{sq} or the \texttt{**} operator.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sqrt(144)         \# 12}
\NormalTok{p sqrt(2)           \# 1.41421356...}
\NormalTok{my $hyp = sqrt($a**2 + $b**2)  \# Pythagorean theorem}
\NormalTok{1:5 |\textgreater{} map sqrt |\textgreater{} e \{ p sprintf("\%.3f", \_) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squared}}{squared}}\label{squared}

Return the square of a number (\texttt{N\ *\ N}). This is a stryke
convenience function --- clearer than writing \texttt{\$n\ **\ 2} or
\texttt{\$n\ *\ \$n} in pipelines. The aliases \texttt{sq} and
\texttt{square} are interchangeable.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p squared(5)        \# 25}
\NormalTok{p sq(12)            \# 144}
\NormalTok{1:5 |\textgreater{} map sq |\textgreater{} e p    \# 1 4 9 16 25}
\NormalTok{my $hyp = sqrt(sq($a) + sq($b))  \# Pythagorean theorem}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cubed}}{cubed}}\label{cubed}

Return the cube of a number (\texttt{N\ *\ N\ *\ N}). This is a stryke
convenience function for the common \texttt{\$n\ **\ 3} operation,
useful in math-heavy pipelines. The aliases \texttt{cb} and
\texttt{cube} are interchangeable.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cubed(3)          \# 27}
\NormalTok{p cb(10)            \# 1000}
\NormalTok{1:4 |\textgreater{} map cb |\textgreater{} e p  \# 1 8 27 64}
\NormalTok{my $vol = cb($side)             \# volume of a cube}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{expt}}{expt}}\label{expt}

Raise a base to an arbitrary exponent and return the result. This is the
function form of the \texttt{**} operator. Accepts integer and
floating-point exponents, including negative values for reciprocals and
fractional values for roots.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p expt(2, 10)       \# 1024}
\NormalTok{p expt(27, 1/3)     \# 3.0 (cube root)}
\NormalTok{p expt(10, {-}2)      \# 0.01}
\NormalTok{1:8 |\textgreater{} map \{ expt(2, \_) \} |\textgreater{} e p  \# 2 4 8 16 32 64 128 256}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp}}{exp}}\label{exp}

Return Euler\textquotesingle s number *e* raised to the given power.
\texttt{exp(0)} is \texttt{1}, \texttt{exp(1)} is approximately
\texttt{2.71828}. This is the inverse of \texttt{log}. Useful for
exponential growth/decay calculations, probability distributions, and
converting between logarithmic and linear scales.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p exp(1)            \# 2.71828182845905}
\NormalTok{p exp(0)            \# 1}
\NormalTok{my $growth = $initial * exp($rate * $time)}
\NormalTok{1:5 |\textgreater{} map exp |\textgreater{} e \{ p sprintf("\%.4f", \_) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log}}{log}}\label{log}

Return the natural (base-*e*) logarithm of a positive number. Dies if
the argument is zero or negative. For base-10 logarithms, divide by
\texttt{log(10)}. For base-2, divide by \texttt{log(2)}. This is the
inverse of \texttt{exp}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p log(exp(1))       \# 1.0}
\NormalTok{p log(100) / log(10)  \# 2.0 (log base 10)}
\NormalTok{my $bits = log($n) / log(2)  \# log base 2}
\NormalTok{1:5 |\textgreater{} map log |\textgreater{} e \{ p sprintf("\%.3f", \_) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sin}}{sin}}\label{sin}

Return the sine of an angle given in radians. The result ranges from
\texttt{-1} to \texttt{1}. For degrees, convert first:
\texttt{sin(\$deg\ *\ 3.14159265\ /\ 180)}. Use \texttt{atan2} to go in
the reverse direction.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sin(0)               \# 0}
\NormalTok{p sin(3.14159265 / 2)  \# 1.0}
\NormalTok{my @wave = map \{ sin(\_ * 0.1) \} 0:62}
\NormalTok{@wave |\textgreater{} e \{ p sprintf("\%6.3f", \_) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cos}}{cos}}\label{cos}

Return the cosine of an angle given in radians. The result ranges from
\texttt{-1} to \texttt{1}. \texttt{cos(0)} is \texttt{1}. Like
\texttt{sin}, convert degrees to radians before calling.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cos(0)                 \# 1}
\NormalTok{p cos(3.14159265)        \# {-}1.0}
\NormalTok{my $x = $radius * cos($theta)}
\NormalTok{my $y = $radius * sin($theta)}
\NormalTok{p "($x, $y)"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atan2}}{atan2}}\label{atan2}

Return the arctangent of \texttt{Y/X} in radians, using the signs of
both arguments to determine the correct quadrant. The result ranges from
\texttt{-pi} to \texttt{pi}. This is the standard way to compute angles
from Cartesian coordinates and is more robust than \texttt{atan(Y/X)}
because it handles \texttt{X=0} correctly.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pi = atan2(0, {-}1)       \# 3.14159265...}
\NormalTok{p atan2(1, 1)               \# 0.785... (pi/4)}
\NormalTok{my $angle = atan2($dy, $dx)}
\NormalTok{p sprintf("\%.1f degrees", $angle * 180 / $pi)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rand}}{rand}}\label{rand}

Return a pseudo-random floating-point number in the range
\texttt{{[}0,\ N)}. If N is omitted it defaults to \texttt{1}. The
result is never exactly equal to N. For integer results, combine with
\texttt{int}. Seed the generator with \texttt{srand} for reproducible
sequences.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p rand()                \# e.g. 0.7342...}
\NormalTok{p int(rand(100))        \# random int 0:99}
\NormalTok{my @deck = 1:52}
\NormalTok{my @shuffled = sort \{ rand() \textless{}=\textgreater{} rand() \} @deck  \# poor shuffle}
\NormalTok{my $coin = rand() \textless{} 0.5 ? "heads" : "tails"}
\NormalTok{p $coin}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{srand}}{srand}}\label{srand}

Seed the pseudo-random number generator used by \texttt{rand}. Calling
\texttt{srand} 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 \texttt{rand}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{srand(42)                   \# reproducible sequence}
\NormalTok{p int(rand(100))            \# always the same value}
\NormalTok{srand(42)}
\NormalTok{p int(rand(100))            \# same value again}
\NormalTok{srand()                     \# re{-}seed from entropy}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-file-system}
\chapter{File System}\label{file-system}

34 topics

\section{\texorpdfstring{\texttt{basename}}{basename}}\label{basename}

Extract the filename component from a path, stripping all leading
directory segments. The short alias \texttt{bn} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p basename("/usr/local/bin/stryke")        \# stryke}
\NormalTok{p bn("/tmp/data.csv", ".csv")           \# data}
\NormalTok{"/etc/nginx/nginx.conf" |\textgreater{} bn |\textgreater{} p      \# nginx.conf}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dirname}}{dirname}}\label{dirname}

Return the directory portion of a path, stripping the final filename
component. The short alias \texttt{dn} mirrors \texttt{bn}. 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dirname("/usr/local/bin/stryke")          \# /usr/local/bin}
\NormalTok{p dn("/tmp/data.csv")                   \# /tmp}
\NormalTok{my $dir = dn($0)                        \# directory of current script}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fileparse}}{fileparse}}\label{fileparse}

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\textquotesingle s
\texttt{File::Basename::fileparse} and is the most flexible path
decomposition available. When no suffix patterns are given the suffix is
empty.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($name, $dir, $sfx) = fileparse("/home/user/report.txt", qr/\textbackslash{}.txt/)}
\NormalTok{p "$dir | $name | $sfx"  \# /home/user/ | report | .txt}
\NormalTok{my ($n, $d) = fileparse("./lib/Foo/Bar.pm")}
\NormalTok{p "$d$n"                 \# ./lib/Foo/Bar.pm}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{realpath}}{realpath}}\label{realpath}

Resolve a path to its absolute canonical form by following all symbolic
links and eliminating \texttt{.} and \texttt{..} segments. Unlike
\texttt{canonpath}, this hits the filesystem and will die if any
component does not exist. The short alias \texttt{rp} is convenient in
pipelines. Use this when you need a guaranteed unique path for
deduplication or comparison.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p realpath(".")                      \# /home/user/project}
\NormalTok{p rp("../sibling")                   \# /home/user/sibling}
\NormalTok{my $canon = rp($0)                  \# absolute path of current script}
\NormalTok{"." |\textgreater{} rp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{canonpath}}{canonpath}}\label{canonpath}

Clean up a file path by collapsing redundant separators, resolving
\texttt{.} and \texttt{..} segments, and normalizing trailing slashes
--- all without touching the filesystem. Unlike \texttt{realpath}, 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p canonpath("/usr/./local/../local/bin/")   \# /usr/local/bin}
\NormalTok{p canonpath("a/b/../c")                     \# a/c}
\NormalTok{my $clean = canonpath($ENV\{HOME\} . "/./docs/../docs")}
\NormalTok{p $clean}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getcwd}}{getcwd}}\label{getcwd}

Return the current working directory as an absolute path string. This
calls the underlying OS \texttt{getcwd} function, so it always reflects
the real directory even if the process changed directories via
\texttt{chdir}. The alias \texttt{pwd} matches the familiar shell
command. Often used to save and restore directory context around
\texttt{chdir} calls.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $orig = pwd()}
\NormalTok{chdir("/tmp")}
\NormalTok{p pwd()      \# /tmp}
\NormalTok{chdir($orig)}
\NormalTok{p getcwd()   \# back to original}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{which}}{which}}\label{which}

Search the \texttt{PATH} environment variable for the first executable
matching the given command name and return its absolute path, or
\texttt{undef} if not found. This is the programmatic equivalent of the
shell \texttt{which} command. Useful for checking tool availability
before calling \texttt{system} or \texttt{exec}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $gcc = which("gcc") // die "gcc not found"}
\NormalTok{p $gcc                       \# /usr/bin/gcc}
\NormalTok{if (which("rg")) \{}
\NormalTok{    system("rg pattern file")}
\NormalTok{\} else \{}
\NormalTok{    system("grep pattern file")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glob}}{glob}}\label{glob}

Expand a zsh-style glob pattern against the filesystem and return a list
of matching paths. World-first: stryke supports \textbf{every} zsh glob
qualifier from \texttt{man\ zshexpn} \_Filename Generation
\textgreater{} Glob Qualifiers\_ (no other scripting language does
this). Backed by \texttt{zsh::glob} from zshrs --- single source of
truth, zero stryke-side reimplementation. Patterns: \texttt{*},
\texttt{?}, \texttt{{[}abc{]}}, \texttt{\{a,b\}}, \texttt{**} recursive,
plus the \texttt{(...)} qualifier suffix.

\subsection{Qualifier reference (full
set)}\label{qualifier-reference-full-set}

\textbf{File type:} \texttt{(/)} dir · \texttt{(.)} regular file ·
\texttt{(@)} symlink · \texttt{(=)} socket · \texttt{(p)} FIFO ·
\texttt{(\%b)} block dev · \texttt{(\%c)} char dev · \texttt{(\%)} any
device · \texttt{(*)} executable file.

\textbf{Permission:} \texttt{(r)} \texttt{(w)} \texttt{(x)} EUID r/w/x ·
\texttt{(R)} \texttt{(W)} \texttt{(X)} world · \texttt{(A)} \texttt{(I)}
\texttt{(E)} group · \texttt{(s)} setuid · \texttt{(S)} setgid ·
\texttt{(t)} sticky · \texttt{(f\textless{}bits\textgreater{})} exact
mode-bit match (e.g. \texttt{(f644)}).

\textbf{Ownership / device:} \texttt{(U)} owned by EUID · \texttt{(G)}
owned by EGID · \texttt{(u\textless{}N\textgreater{})} uid N ·
\texttt{(g\textless{}N\textgreater{})} gid N ·
\texttt{(d\textless{}N\textgreater{})} match by device number.

\textbf{Numeric} (each accepts \texttt{+N} greater, \texttt{-N} less,
\texttt{N} equal): \texttt{(L{[}unit{]}±N)} size ---
\texttt{p}/\texttt{k}/\texttt{m}/\texttt{g}/\texttt{t} units, default
bytes · \texttt{(l±N)} link count · \texttt{(a{[}unit{]}±N)} atime ·
\texttt{(m{[}unit{]}±N)} mtime · \texttt{(c{[}unit{]}±N)} ctime --- time
units \texttt{s}/\texttt{m}/\texttt{h}/\texttt{d}/\texttt{w}/\texttt{M}.

\textbf{Sort:} \texttt{(on)} \texttt{(oL)} \texttt{(ol)} \texttt{(oa)}
\texttt{(om)} \texttt{(oc)} \texttt{(od)} ascending; capital \texttt{O*}
descending; \texttt{(oN)} no sort.

\textbf{Selection:} \texttt{({[}N{]})} Nth match · \texttt{({[}N,M{]})}
slice. Combine with sort: \texttt{(om{[}1{]})} newest single match.

\textbf{Flags:} \texttt{(N)} NULL\_GLOB --- empty list on no match ·
\texttt{(D)} include dotfiles · \texttt{(F)} non-empty directory ·
\texttt{(M)} mark-dirs (append \texttt{/}) · \texttt{(T)} list-types
(append type char) · \texttt{(n)} numeric sort.

\textbf{Eval / functions:}
\texttt{(e\textquotesingle{}CMD\textquotesingle{})} shell-eval predicate
· \texttt{(+func)} function-as-test (predicate sub).

\textbf{Join words:} \texttt{(P…)} prefix words · \texttt{(Q…)} postfix
words around each match.

\textbf{Colon modifiers:} \texttt{(:s/PAT/REPL/)} sed substitution on
each path · \texttt{(:e)} extension · \texttt{(:r)} strip extension ·
\texttt{(:t)} tail · \texttt{(:h)} head · all of zsh\textquotesingle s
history-style modifiers.

\textbf{Combinators:} prefix \texttt{\^{}} negates · prefix \texttt{-}
toggles symlink-following · \texttt{,} separates OR alternatives ·
chained qualifiers AND.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @scripts = glob("*.pl")}
\NormalTok{my @all\_rs = glob("src/**/*.rs")}
\NormalTok{my @dirs = glob("**(/)")           \# directories only, recursive}
\NormalTok{my @big = glob("**(L+1024)")       \# files larger than 1024 bytes}
\NormalTok{my @recent = glob("**(om[1])")     \# most recently modified, take 1}
\NormalTok{my @safe = glob("missing*(N)")     \# null{-}glob, never errors}
\NormalTok{my @mode = glob("**(f644)")        \# files with exactly mode 644}
\NormalTok{my @stems = glob("*.txt(:r)")      \# all .txt files, extension stripped}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glob\_match}}{glob\_match}}\label{glob_match}

Test whether a string matches a shell-style glob pattern. Returns true
(1) on match, false (empty string) otherwise. Supports \texttt{*},
\texttt{?}, \texttt{{[}abc{]}}, and \texttt{\{a,b\}}. 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 \texttt{(/)} or \texttt{(.)} are stat-based filters that only apply
at filesystem-expansion time
(\texttt{glob}/\texttt{glob\_par}/\texttt{slurp}); \texttt{glob\_match}
ignores any trailing qualifier.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p glob\_match("*.pl", "script.pl")        \# 1}
\NormalTok{p glob\_match("*.pl", "script.py")        \# (empty)}
\NormalTok{my @perl = grep \{ glob\_match("*.\{pl,pm\}", \_) \} @files}
\NormalTok{@perl |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{copy}}{copy}}\label{copy}

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
\texttt{cp} and avoids shelling out. Metadata such as permissions is
preserved where possible.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{copy("src/config.yaml", "/tmp/config.yaml")}
\NormalTok{copy("report.pdf", "/backup/")}
\NormalTok{my $tmp = tf()}
\NormalTok{copy($0, $tmp)  \# back up the current script}
\NormalTok{p slurp($tmp)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{move}}{move}}\label{move}

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 \texttt{mv} mirrors the shell command.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{move("draft.txt", "final.txt")         \# rename in place}
\NormalTok{mv("output.csv", "/archive/output.csv") \# move across dirs}
\NormalTok{my $tmp = tf()}
\NormalTok{spurt($tmp, "data")}
\NormalTok{mv($tmp, "data.txt")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rename}}{rename}}\label{rename}

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
\texttt{move}/\texttt{mv}, this does not fall back to copy-then-delete
across filesystems.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{rename("draft.md", "final.md")}
\NormalTok{rename("output", "output\_v2")          \# works on dirs too}
\NormalTok{my $bak = "config.yaml.bak"}
\NormalTok{rename("config.yaml", $bak)}
\NormalTok{spurt("config.yaml", $new\_config)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unlink}}{unlink}}\label{unlink}

Delete one or more files from the filesystem. Returns the number of
files successfully removed. Does not remove directories --- use
\texttt{rmdir} for those. Dies on permission errors. Accepts a list of
paths, making it convenient for batch cleanup.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{unlink("temp.log")}
\NormalTok{my $n = unlink("a.tmp", "b.tmp", "c.tmp")}
\NormalTok{p "removed $n files"}
\NormalTok{my @old = glob("*.bak")}
\NormalTok{unlink(@old)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mkdir}}{mkdir}}\label{mkdir}

Create a directory at the given path. An optional second argument
specifies the permission mode as an octal number (default \texttt{0777},
modified by the current \texttt{umask}). Dies if the directory cannot be
created. Only creates one level --- use \texttt{make\_path} or shell out
for recursive creation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{mkdir("output")}
\NormalTok{mkdir("/tmp/secure", 0700)}
\NormalTok{my $dir = tdr() . "/sub"}
\NormalTok{mkdir($dir)}
\NormalTok{p {-}d $dir    \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rmdir}}{rmdir}}\label{rmdir}

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 \texttt{unlink} first, then call \texttt{rmdir}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{mkdir("scratch")}
\NormalTok{rmdir("scratch")}
\NormalTok{p {-}d "scratch"   \# (empty, dir is gone)}
\NormalTok{unlink("tmp/file.txt")}
\NormalTok{rmdir("tmp")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chmod}}{chmod}}\label{chmod}

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 \texttt{stat} to read
the current mode before modifying.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{chmod(0755, "script.pl")}
\NormalTok{chmod(0644, "config.yaml", "data.json")}
\NormalTok{my $n = chmod(0600, glob("*.key"))}
\NormalTok{p "secured $n key files"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chown}}{chown}}\label{chown}

Change the owner and group of one or more files, specified as numeric
UID and GID. Pass \texttt{-1} for either to leave it unchanged. Returns
the number of files successfully changed. Typically requires root
privileges.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{chown(1000, 1000, "app.log")}
\NormalTok{chown({-}1, 100, "shared.txt")     \# change group only}
\NormalTok{my $uid = (getpwnam("deploy"))[2]}
\NormalTok{chown($uid, {-}1, "release.tar")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chdir}}{chdir}}\label{chdir}

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
\texttt{getcwd}/\texttt{pwd} to save and restore the original directory.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $orig = pwd()}
\NormalTok{chdir("/tmp")}
\NormalTok{spurt("scratch.txt", "hello")}
\NormalTok{chdir($orig)                  \# return to original}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stat}}{stat}}\label{stat}

Return a 13-element list of file status information for a path or
filehandle:
\texttt{(\$dev,\ \$ino,\ \$mode,\ \$nlink,\ \$uid,\ \$gid,\ \$rdev,\ \$size,\ \$atime,\ \$mtime,\ \$ctime,\ \$blksize,\ \$blocks)}.
This calls the POSIX \texttt{stat} system call. Use it to check file
size, modification time, permissions, and other metadata without reading
the file.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @st = stat("data.bin")}
\NormalTok{p "size: $st[7] bytes"}
\NormalTok{p "modified: " . datetime\_from\_epoch($st[9])}
\NormalTok{my ($mode) = (stat($0))[2]}
\NormalTok{p sprintf("perms: \%04o", $mode \& 07777)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{link}}{link}}\label{link}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{link("data.csv", "data\_backup.csv")}
\NormalTok{my @st1 = stat("data.csv")}
\NormalTok{my @st2 = stat("data\_backup.csv")}
\NormalTok{p $st1[1] == $st2[1]   \# 1 — same inode}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{symlink}}{symlink}}\label{symlink}

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 \texttt{readlink} to inspect where a symlink points.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{symlink("/usr/local/bin/stryke", "pe\_link")}
\NormalTok{p readlink("pe\_link")       \# /usr/local/bin/stryke}
\NormalTok{p {-}l "pe\_link"              \# 1 (is a symlink)}
\NormalTok{symlink("../lib", "lib\_link")  \# relative target}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{readlink}}{readlink}}\label{readlink}

Return the target path that a symbolic link points to, without following
the link further. Returns \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{symlink("real.conf", "link.conf")}
\NormalTok{my $target = readlink("link.conf")}
\NormalTok{p $target                    \# real.conf}
\NormalTok{if (defined readlink($path)) \{}
\NormalTok{    p "$path is a symlink"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{utime}}{utime}}\label{utime}

Set the access time and modification time of one or more files. Times
are specified as epoch seconds. Pass \texttt{undef} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{utime(time(), time(), "output.txt")     \# touch to now}
\NormalTok{my $epoch = 1700000000}
\NormalTok{utime($epoch, $epoch, @files)           \# backdate files}
\NormalTok{utime(undef, undef, "marker.flag")      \# equivalent of touch}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{umask}}{umask}}\label{umask}

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 \texttt{mkdir}, \texttt{open}, etc.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $old = umask(0077)         \# restrict: owner{-}only}
\NormalTok{mkdir("private")               \# created with 0700}
\NormalTok{umask($old)                    \# restore previous mask}
\NormalTok{p sprintf("\%04o", umask())     \# print current mask}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uname}}{uname}}\label{uname}

Return system identification as a five-element list:
\texttt{(\$sysname,\ \$nodename,\ \$release,\ \$version,\ \$machine)}.
This calls the POSIX \texttt{uname} system call and is useful for
platform-specific logic, logging system info, or generating diagnostic
reports without shelling out.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($sys, $node, $rel, $ver, $arch) = uname()}
\NormalTok{p "$sys $rel ($arch)"           \# Linux 6.1.0 (x86\_64)}
\NormalTok{if ($sys eq "Darwin") \{}
\NormalTok{    p "running on macOS"}
\NormalTok{\}}
\NormalTok{log\_info("host: $node, kernel: $rel")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gethostname}}{gethostname}}\label{gethostname}

Return the hostname of the current machine as a string. This calls the
POSIX \texttt{gethostname} system call. The short alias \texttt{hn} is
useful in log prefixes, temp-file naming, or distributed-system
identifiers where you need to tag output by machine.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gethostname()                          \# myhost.local}
\NormalTok{my $log\_prefix = hn() . ":" . $$        \# myhost.local:12345}
\NormalTok{log\_info("running on " . hn())}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{opendir}}{opendir}}\label{opendir}

Open a directory handle for reading its entries. Returns a directory
handle that can be passed to \texttt{readdir}, \texttt{seekdir},
\texttt{telldir}, \texttt{rewinddir}, and \texttt{closedir}. Dies if the
directory does not exist or cannot be opened. For most use cases
\texttt{glob} or \texttt{readdir} with a path is simpler.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{opendir(my $dh, "/tmp") or die "cannot open: $!"}
\NormalTok{my @entries = readdir($dh)}
\NormalTok{closedir($dh)}
\NormalTok{@entries |\textgreater{} grep \{ \_ !\textasciitilde{} /\^{}\textbackslash{}./ \} |\textgreater{} e p  \# skip dotfiles}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{readdir}}{readdir}}\label{readdir}

Read entries from a directory handle opened with \texttt{opendir}. In
list context, returns all remaining entries. In scalar context, returns
the next single entry or \texttt{undef} when exhausted. Entries include
\texttt{.} and \texttt{..} so you typically filter them out.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{opendir(my $dh, ".") or die $!}
\NormalTok{while (my $entry = readdir($dh)) \{}
\NormalTok{    next if $entry =\textasciitilde{} /\^{}\textbackslash{}./}
\NormalTok{    p $entry}
\NormalTok{\}}
\NormalTok{closedir($dh)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{closedir}}{closedir}}\label{closedir}

Close a directory handle previously opened with \texttt{opendir},
releasing the underlying OS resource. While directory handles are closed
automatically when they go out of scope, explicit \texttt{closedir} is
good practice in long-running programs or loops that open many
directories.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{opendir(my $dh, "/var/log") or die $!}
\NormalTok{my @logs = readdir($dh)}
\NormalTok{closedir($dh)}
\NormalTok{@logs |\textgreater{} grep \{ /\textbackslash{}.log$/ \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seekdir}}{seekdir}}\label{seekdir}

Set the current position in a directory handle to a location previously
obtained from \texttt{telldir}. This allows you to revisit directory
entries without closing and reopening the handle. Rarely needed in
practice, but useful for multi-pass directory scanning.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{opendir(my $dh, ".") or die $!}
\NormalTok{my $pos = telldir($dh)}
\NormalTok{my @first\_pass = readdir($dh)}
\NormalTok{seekdir($dh, $pos)              \# rewind to saved position}
\NormalTok{my @second\_pass = readdir($dh)}
\NormalTok{closedir($dh)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{telldir}}{telldir}}\label{telldir}

Return the current read position within a directory handle as an opaque
integer. The returned value can be passed to \texttt{seekdir} to return
to that position later. This is the directory-handle equivalent of
\texttt{tell} for file handles.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{opendir(my $dh, "/tmp") or die $!}
\NormalTok{readdir($dh)                  \# skip .}
\NormalTok{readdir($dh)                  \# skip ..}
\NormalTok{my $pos = telldir($dh)        \# save position after . and ..}
\NormalTok{my @real = readdir($dh)}
\NormalTok{seekdir($dh, $pos)            \# go back}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rewinddir}}{rewinddir}}\label{rewinddir}

Reset a directory handle back to the beginning so that the next
\texttt{readdir} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{opendir(my $dh, "src") or die $!}
\NormalTok{my $count = scalar readdir($dh)}
\NormalTok{rewinddir($dh)}
\NormalTok{my @entries = readdir($dh)}
\NormalTok{closedir($dh)}
\NormalTok{p "$count entries"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{du}}{du}}\label{du}

\texttt{du} (alias \texttt{dir\_size}) --- compute the total size of a
directory tree in bytes, recursively walking all files.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $bytes = du("/usr/local")}
\NormalTok{p "$bytes bytes"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{du\_tree}}{du\_tree}}\label{du_tree}

\texttt{du\_tree} (alias \texttt{dir\_sizes}) --- return directory sizes
as an array of hashrefs \texttt{\{path,\ size\}}, sorted descending by
size. Each entry is an immediate child directory.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @dirs = du\_tree("/usr/local")}
\NormalTok{for (@dirs) \{ p "\_{-}\textgreater{}\{path\}: \_{-}\textgreater{}\{size\}" \}}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-process}
\chapter{Process}\label{process}

21 topics

\section{\texorpdfstring{\texttt{system}}{system}}\label{system}

Execute a command in a subshell and wait for it to complete, returning
the exit status. A return value of \texttt{0} means success; non-zero
indicates failure. The exit status is encoded as
\texttt{\$?\ \textgreater{}\textgreater{}\ 8} for the actual exit code.
Use backticks or \texttt{capture} if you need the
command\textquotesingle s output.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $rc = system("make", "test")}
\NormalTok{p "exit code: " . ($rc \textgreater{}\textgreater{} 8)}
\NormalTok{system("cp data.csv /backup/") == 0 or die "copy failed"}
\NormalTok{if (system("which rg \textgreater{}/dev/null 2\textgreater{}\&1") == 0) \{}
\NormalTok{    p "ripgrep is installed"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exec}}{exec}}\label{exec}

Replace the current process image entirely with a new command. This
never returns on success --- the new program takes over. If
\texttt{exec} fails (command not found, permission denied) it returns
false and execution continues. Use \texttt{system} instead if you want
to run a command and keep the current process alive.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{exec("ls", "{-}la", "/tmp") or die "exec failed: $!"}
\NormalTok{\# code here only runs if exec fails}

\NormalTok{\# common fork+exec pattern}
\NormalTok{if (fork() == 0) \{}
\NormalTok{    exec("worker", "{-}{-}daemon")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fork}}{fork}}\label{fork}

Fork the current process, creating a child that is an exact copy of the
parent. Returns the child\textquotesingle s PID to the parent process
and \texttt{0} to the child, allowing each side to branch. Returns
\texttt{undef} on failure. Always pair with
\texttt{wait}/\texttt{waitpid} to reap the child and avoid zombies.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pid = fork()}
\NormalTok{if ($pid == 0) \{}
\NormalTok{    p "child $$"}
\NormalTok{    exit(0)}
\NormalTok{\}}
\NormalTok{p "parent $$, child is $pid"}
\NormalTok{waitpid($pid, 0)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wait}}{wait}}\label{wait}

Wait for any child process to terminate and return its PID. The exit
status is stored in \texttt{\$?}. If there are no child processes,
returns \texttt{-1}. This is the simplest reaping function --- use
\texttt{waitpid} when you need to wait for a specific child or use
non-blocking flags.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{for (1:3) \{}
\NormalTok{    fork() or do \{ sleep(1)}
\NormalTok{    exit(0) \}}
\NormalTok{\}}
\NormalTok{while ((my $pid = wait()) != {-}1) \{}
\NormalTok{    p "child $pid exited with " . ($? \textgreater{}\textgreater{} 8)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{waitpid}}{waitpid}}\label{waitpid}

Wait for a specific child process identified by PID to change state. The
flags argument controls behavior --- use \texttt{0} for blocking wait,
or \texttt{WNOHANG} for non-blocking (returns \texttt{0} if child is
still running). Returns the PID on success, \texttt{-1} if the child
does not exist. Exit status is in \texttt{\$?}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pid = fork() // die "fork: $!"}
\NormalTok{if ($pid == 0) \{ sleep(2)}
\NormalTok{    exit(42) \}}
\NormalTok{waitpid($pid, 0)}
\NormalTok{p "child exited: " . ($? \textgreater{}\textgreater{} 8)   \# 42}

\NormalTok{\# non{-}blocking poll}
\NormalTok{while (waitpid($pid, WNOHANG) == 0) \{}
\NormalTok{    p "still running..."}
\NormalTok{    sleep(1)}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kill}}{kill}}\label{kill}

Send a signal to one or more processes by PID. The signal can be
specified as a number (\texttt{9}) or a name (\texttt{"TERM"}). Sending
signal \texttt{0} tests whether the process exists without actually
sending anything. Returns the number of processes successfully signaled.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{kill("TERM", $child\_pid)}
\NormalTok{kill(9, @worker\_pids)                \# SIGKILL}
\NormalTok{if (kill(0, $pid)) \{}
\NormalTok{    p "process $pid is alive"}
\NormalTok{\}}
\NormalTok{my $n = kill("HUP", @daemons)}
\NormalTok{p "signaled $n processes"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exit}}{exit}}\label{exit}

Terminate the program immediately with the given exit status code. An
exit code of \texttt{0} conventionally means success; any non-zero value
indicates an error. \texttt{END} blocks and object destructors are still
run. Use \texttt{POSIX::\_exit} to skip cleanup entirely.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{exit(0)                 \# success}
\NormalTok{exit(1) if $error       \# failure}

\NormalTok{\# conditional exit in a pipeline}
\NormalTok{my $ok = system("make test")}
\NormalTok{exit($ok \textgreater{}\textgreater{} 8) if $ok}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getlogin}}{getlogin}}\label{getlogin}

Return the login name of the user who owns the current terminal session.
This reads from the system\textquotesingle s utmp/utmpx database and may
return \texttt{undef} for processes without a controlling terminal (cron
jobs, daemons). For a more reliable alternative, use
\texttt{getpwuid(\$\textless{})} which looks up the effective UID.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $user = getlogin() // (getpwuid($\textless{}))[0]}
\NormalTok{p "running as $user"}
\NormalTok{log\_info("session started by " . getlogin())}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getpwnam}}{getpwnam}}\label{getpwnam}

Look up user account information by username string. Returns the same
9-element list as \texttt{getpwuid}:
\texttt{(\$name,\ \$passwd,\ \$uid,\ \$gid,\ \$quota,\ \$comment,\ \$gcos,\ \$dir,\ \$shell)}.
Returns empty list if the user does not exist. Useful for resolving a
username to a UID before calling \texttt{chown}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @info = getpwnam("deploy")}
\NormalTok{p "uid=$info[2] home=$info[7]"}
\NormalTok{my $uid = (getpwnam("www{-}data"))[2]}
\NormalTok{chown($uid, {-}1, "public/index.html")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getpwuid}}{getpwuid}}\label{getpwuid}

Look up user account information by numeric UID. Returns
\texttt{(\$name,\ \$passwd,\ \$uid,\ \$gid,\ \$quota,\ \$comment,\ \$gcos,\ \$dir,\ \$shell)}
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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($name, undef, undef, undef, undef, undef, undef, $home) = getpwuid($\textless{})}
\NormalTok{p "user: $name, home: $home"}
\NormalTok{my $root\_shell = (getpwuid(0))[8]}
\NormalTok{p $root\_shell   \# /bin/bash or /bin/zsh}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getpwent}}{getpwent}}\label{getpwent}

Read the next entry from the system password database, iterating through
all user accounts. Returns
\texttt{(\$name,\ \$passwd,\ \$uid,\ \$gid,\ \$quota,\ \$comment,\ \$gcos,\ \$dir,\ \$shell)}
for each user, or empty list when exhausted. Call \texttt{setpwent} to
rewind and \texttt{endpwent} to close.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{while (my @pw = getpwent()) \{}
\NormalTok{    p "$pw[0]: uid=$pw[2] home=$pw[7]"}
\NormalTok{\}}
\NormalTok{endpwent()}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getgrgid}}{getgrgid}}\label{getgrgid}

Look up group information by numeric GID. Returns
\texttt{(\$name,\ \$passwd,\ \$gid,\ \$members)} where members is a
space-separated string of usernames belonging to the group. Returns
empty list if the GID does not exist.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($name, undef, undef, $members) = getgrgid(0)}
\NormalTok{p "group $name: $members"}
\NormalTok{my $gname = (getgrgid((stat("file.txt"))[5]))[0]}
\NormalTok{p "file group: $gname"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getgrnam}}{getgrnam}}\label{getgrnam}

Look up group information by group name string. Returns
\texttt{(\$name,\ \$passwd,\ \$gid,\ \$members)}. Useful for resolving a
group name to a GID before calling \texttt{chown}, or for checking group
membership.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($name, undef, $gid, $members) = getgrnam("staff")}
\NormalTok{p "gid=$gid members=$members"}
\NormalTok{chown({-}1, $gid, "shared\_dir")}
\NormalTok{if ((getgrnam("admin"))[3] =\textasciitilde{} /\textbackslash{}b$user\textbackslash{}b/) \{}
\NormalTok{    p "$user is an admin"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getgrent}}{getgrent}}\label{getgrent}

Read the next entry from the system group database, iterating through
all groups. Returns \texttt{(\$name,\ \$passwd,\ \$gid,\ \$members)} for
each group, or empty list when exhausted. The members field is a
space-separated string of usernames. Call \texttt{endgrent} when done.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{while (my @gr = getgrent()) \{}
\NormalTok{    p "$gr[0]: gid=$gr[2] members=$gr[3]"}
\NormalTok{\}}
\NormalTok{endgrent()}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getppid}}{getppid}}\label{getppid}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p "my pid: $$, parent: " . getppid()}
\NormalTok{if (getppid() == 1) \{}
\NormalTok{    log\_warn("parent process has exited, we are orphaned")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getpgrp}}{getpgrp}}\label{getpgrp}

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
\texttt{setpgrp} to move a process into a different group.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p "process group: " . getpgrp()}
\NormalTok{my $pg = getpgrp($$)}
\NormalTok{p $pg == $$ ? "group leader" : "group member"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setpgrp}}{setpgrp}}\label{setpgrp}

Set the process group ID of a process. Call \texttt{setpgrp(0,\ 0)} to
make the current process a new group leader, which is useful for
daemonization or isolating a subprocess from the
terminal\textquotesingle s signal group. Takes \texttt{(PID,\ PGID)} ---
use \texttt{0} for the current process.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{setpgrp(0, 0)   \# become process group leader}
\NormalTok{if (fork() == 0) \{}
\NormalTok{    setpgrp(0, 0)  \# child gets its own group}
\NormalTok{    exec("worker")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getpriority}}{getpriority}}\label{getpriority}

Get the scheduling priority (nice value) of a process, process group, or
user. The \texttt{which} argument selects the target type:
\texttt{PRIO\_PROCESS}, \texttt{PRIO\_PGRP}, or \texttt{PRIO\_USER}.
Lower values mean higher priority. The default nice value is \texttt{0};
range is typically \texttt{-20} to \texttt{19}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $nice = getpriority(0, $$)    \# PRIO\_PROCESS, current PID}
\NormalTok{p "nice value: $nice"}
\NormalTok{my $user\_prio = getpriority(2, $\textless{})  \# PRIO\_USER, current user}
\NormalTok{p "user priority: $user\_prio"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setpriority}}{setpriority}}\label{setpriority}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{setpriority(0, $$, 10)   \# lower priority for batch work}
\NormalTok{if (fork() == 0) \{}
\NormalTok{    setpriority(0, 0, 19)  \# lowest priority for child}
\NormalTok{    exec("batch{-}job")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{syscall}}{syscall}}\label{syscall}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# SYS\_getpid on Linux x86\_64 is 39}
\NormalTok{my $pid = syscall(39)}
\NormalTok{p $pid                     \# same as $$}
\NormalTok{\# SYS\_sync on Linux is 162}
\NormalTok{syscall(162)               \# flush filesystem caches}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{process\_list}}{process\_list}}\label{process_list}

\texttt{process\_list} (aliases \texttt{ps}, \texttt{procs}) --- list
running processes as an array of hashrefs with
\texttt{\{pid,\ name,\ uid\}} keys.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @procs = ps()}
\NormalTok{for (@procs) \{ p "\_{-}\textgreater{}\{pid\} \_{-}\textgreater{}\{name\}" \}}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-pack-binary}
\chapter{Pack / Binary}\label{pack-binary}

4 topics

\section{\texorpdfstring{\texttt{pack}}{pack}}\label{pack}

Convert a list of values into a binary string according to a template.
Each template character specifies how one value is encoded: \texttt{N}
for 32-bit big-endian unsigned, \texttt{n} for 16-bit, \texttt{a} for
raw bytes, \texttt{Z} for null-terminated string, etc. This is essential
for constructing binary protocols, file formats, and \texttt{sockaddr}
structures.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $bin = pack("NnA4", 0xDEADBEEF, 8080, "test")}
\NormalTok{p length($bin)                \# 10 bytes}
\NormalTok{my $header = pack("A8 N N", "MAGIC01\textbackslash{}0", 1, 42)}
\NormalTok{spurt("data.bin", $header)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unpack}}{unpack}}\label{unpack}

Decode a binary string into a list of values according to a template,
performing the inverse of \texttt{pack}. 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($magic, $version, $count) = unpack("A8 N N", $header)}
\NormalTok{p "v$version, $count records"}
\NormalTok{my ($port, $addr) = unpack("n a4", $sockaddr)}
\NormalTok{p inet\_ntoa($addr) . ":$port"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unpack\_first}}{unpack\_first}}\label{unpack_first}

\texttt{unpack\_first(FMT,\ STR)} --- decode the binary string and
return the \textbf{first} decoded element (or \texttt{undef} if the
format yields nothing). The stryke spelling of Perl\textquotesingle s
\texttt{scalar\ unpack(FMT,\ STR)} for \texttt{-\/-no-interop} mode
where \texttt{scalar} is rejected at parse time. Aliases:
\texttt{unpack1}, \texttt{up1}. Equivalent to
\texttt{head(unpack(FMT,\ STR))} but spelled as a single verb.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $first\_byte = unpack\_first("C", $bytes)}
\NormalTok{my $port       = unpack1("n", $sockaddr)}
\NormalTok{my $magic\_word = up1("N", $header)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec}}{vec}}\label{vec}

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, \texttt{vec} modifies the string in place. Useful for
compact boolean arrays and bitmap manipulation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $bits = ""}
\NormalTok{vec($bits, 0, 1) = 1   \# set bit 0}
\NormalTok{vec($bits, 7, 1) = 1   \# set bit 7}
\NormalTok{p vec($bits, 0, 1)     \# 1}
\NormalTok{p vec($bits, 3, 1)     \# 0}
\NormalTok{p unpack("B8", $bits)  \# 10000001}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-logging}
\chapter{Logging}\label{logging}

7 topics

\section{\texorpdfstring{\texttt{log\_info}}{log\_info}}\label{log_info}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{log\_info("server started on port $port")}
\NormalTok{my @rows = rl("data.csv")}
\NormalTok{log\_info("loaded " . scalar(@rows) . " rows")}
\NormalTok{1:5 |\textgreater{} e \{ log\_info("processing item $\_") \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_warn}}{log\_warn}}\label{log_warn}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{log\_warn("config file not found, using defaults")}
\NormalTok{log\_warn("query took $\{elapsed\}s, exceeds threshold")}
\NormalTok{unless ({-}e $path) \{}
\NormalTok{    log\_warn("$path missing, skipping")}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_error}}{log\_error}}\label{log_error}

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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{log\_error("failed to connect to $host: $!")}
\NormalTok{eval \{ rj("bad.json") \}}
\NormalTok{log\_error("parse failed: $@") if $@}
\NormalTok{log\_error("missing required field \textquotesingle{}name\textquotesingle{}")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_debug}}{log\_debug}}\label{log_debug}

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 \texttt{log\_level}. Use for detailed internal state that helps
during development --- variable dumps, branch decisions, intermediate
values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{log\_level("debug")}
\NormalTok{log\_debug("cache key: $key")}
\NormalTok{my $result = compute($x)}
\NormalTok{log\_debug("compute($x) =\textgreater{} $result")}
\NormalTok{@items |\textgreater{} e \{ log\_debug("item: $\_") \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_trace}}{log\_trace}}\label{log_trace}

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 \texttt{log\_level("trace")}
is set. Use sparingly in production code; primarily for deep debugging
sessions.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{log\_level("trace")}
\NormalTok{fn process($x) \{}
\NormalTok{    log\_trace("entering process($x)")}
\NormalTok{    my $r = $x * 2}
\NormalTok{    log\_trace("leaving process =\textgreater{} $r")}
\NormalTok{    $r}
\NormalTok{\}}
\NormalTok{1:3 |\textgreater{} map process |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_json}}{log\_json}}\label{log_json}

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 \texttt{jq}-friendly output. Each call emits
exactly one JSON object per line.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{log\_json("request", method =\textgreater{} "GET", path =\textgreater{} "/api")}
\NormalTok{log\_json("metric", name =\textgreater{} "latency\_ms", value =\textgreater{} 42)}
\NormalTok{log\_json("error", msg =\textgreater{} $@, file =\textgreater{} $0)$1}

\NormalTok{Note: all values are serialized as JSON strings.}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_level}}{log\_level}}\label{log_level}

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: \texttt{trace}, \texttt{debug}, \texttt{info}, \texttt{warn},
\texttt{error}. The default level is \texttt{info}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p log\_level()         \# info}
\NormalTok{log\_level("debug")    \# enable debug output}
\NormalTok{log\_debug("now visible")}
\NormalTok{log\_level("error")    \# suppress everything below error}
\NormalTok{log\_info("hidden")    \# not printed}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-charts-svg}
\chapter{Charts (SVG)}\label{charts-svg}

19 topics

\section{\texorpdfstring{\texttt{scatter\_svg}}{scatter\_svg}}\label{scatter_svg}

\texttt{scatter\_svg} (alias \texttt{scatter\_plot}) --- generate an SVG
scatter plot. Args: xs, ys {[}, title{]}. Dark theme, auto-scaled axes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{scatter\_svg([1,2,3,4], [1,4,9,16], "Squares") |\textgreater{} to\_file("scatter.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{line\_svg}}{line\_svg}}\label{line_svg}

\texttt{line\_svg} (alias \texttt{line\_plot}) --- generate an SVG line
plot. Args: xs, ys {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = map \{ \_ * 0.1 \} 0:100}
\NormalTok{my @y = map \{ sin(\_) \} @x}
\NormalTok{line\_svg(\textbackslash{}@x, \textbackslash{}@y, "Sine") |\textgreater{} to\_file("sine.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plot\_svg}}{plot\_svg}}\label{plot_svg}

\texttt{plot\_svg} --- SVG line plot with auto X axis (0..n-1). Args: ys
{[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{plot\_svg([map \{ \_ ** 2 \} 0:50], "Parabola") |\textgreater{} to\_file("plot.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hist\_svg}}{hist\_svg}}\label{hist_svg}

\texttt{hist\_svg} (alias \texttt{histogram\_svg}) --- SVG histogram
with auto-binning (sqrt rule). Args: data {[}, bins, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{rnorm(1000) |\textgreater{} hist\_svg(30, "Normal") |\textgreater{} to\_file("hist.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boxplot\_svg}}{boxplot\_svg}}\label{boxplot_svg}

\texttt{boxplot\_svg} (alias \texttt{box\_plot}) --- SVG box-and-whisker
plot with IQR whiskers and outlier detection. Args: groups {[},
title{]}. Groups is array of arrays.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{boxplot\_svg([[1,2,3,4,5], [3,4,5,6,20]], "Compare") |\textgreater{} to\_file("box.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bar\_svg}}{bar\_svg}}\label{bar_svg}

\texttt{bar\_svg} (alias \texttt{barchart\_svg}) --- SVG bar chart with
labeled bars and value annotations. Args: labels, values {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{bar\_svg(["Rust","Go","C++"], [45,30,25], "Languages") |\textgreater{} to\_file("bar.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pie\_svg}}{pie\_svg}}\label{pie_svg}

\texttt{pie\_svg} (alias \texttt{pie\_chart}) --- SVG pie chart with
percentage labels. Args: labels, values {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{pie\_svg(["A","B","C"], [50,30,20]) |\textgreater{} to\_file("pie.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heatmap\_svg}}{heatmap\_svg}}\label{heatmap_svg}

\texttt{heatmap\_svg} (alias \texttt{heatmap}) --- SVG heatmap with
blue-cyan-yellow-red colormap. Args: matrix {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{heatmap\_svg(cor\_mat($data), "Correlation") |\textgreater{} to\_file("heat.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{donut\_svg}}{donut\_svg}}\label{donut_svg}

\texttt{donut\_svg} (alias \texttt{donut}) --- SVG donut chart with
percentage labels. Accepts labels+values or a hashref.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{donut\_svg(["A","B","C"], [50,30,20], "Share") |\textgreater{} to\_file("donut.svg")}
\NormalTok{\{Rust =\textgreater{} 45, Go =\textgreater{} 30\} |\textgreater{} donut("Languages") |\textgreater{} to\_file("donut.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{area\_svg}}{area\_svg}}\label{area_svg}

\texttt{area\_svg} (alias \texttt{area\_chart}) --- SVG filled area
chart. Args: xs, ys {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = 0:20}
\NormalTok{my @y = map \{ sin(\_ * 0.3) \} @x}
\NormalTok{area\_svg(\textbackslash{}@x, \textbackslash{}@y, "Wave") |\textgreater{} to\_file("area.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hbar\_svg}}{hbar\_svg}}\label{hbar_svg}

\texttt{hbar\_svg} (alias \texttt{hbar}) --- SVG horizontal bar chart.
Accepts labels+values or a hashref.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{hbar\_svg(["Rust","Go","C++"], [45,30,25], "Speed") |\textgreater{} to\_file("hbar.svg")}
\NormalTok{\{alpha =\textgreater{} 10, beta =\textgreater{} 20\} |\textgreater{} hbar |\textgreater{} to\_file("hbar.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{radar\_svg}}{radar\_svg}}\label{radar_svg}

\texttt{radar\_svg} (aliases \texttt{radar}, \texttt{spider}) --- SVG
radar/spider chart. Args: labels, values {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{radar\_svg(["Atk","Def","Spd","HP","MP"], [8,6,9,5,7], "Stats") |\textgreater{} to\_file("radar.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{candlestick\_svg}}{candlestick\_svg}}\label{candlestick_svg}

\texttt{candlestick\_svg} (aliases \texttt{candlestick}, \texttt{ohlc})
--- SVG candlestick OHLC chart. Args: array of {[}open,high,low,close{]}
{[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{candlestick\_svg([[100,110,95,105],[105,115,100,112]], "Stock") |\textgreater{} to\_file("ohlc.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{violin\_svg}}{violin\_svg}}\label{violin_svg}

\texttt{violin\_svg} (alias \texttt{violin}) --- SVG violin plot from
array of arrays showing distribution shape.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{violin\_svg([rnorm(200), rnorm(200, 2)], "Distributions") |\textgreater{} to\_file("violin.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cor\_heatmap}}{cor\_heatmap}}\label{cor_heatmap}

\texttt{cor\_heatmap} (alias \texttt{cor\_matrix\_svg}) --- SVG
correlation matrix heatmap. Computes pairwise correlations and renders
as heatmap.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{cor\_heatmap([rnorm(100), rnorm(100), rnorm(100)], "Correlations") |\textgreater{} to\_file("cor.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stacked\_bar\_svg}}{stacked\_bar\_svg}}\label{stacked_bar_svg}

\texttt{stacked\_bar\_svg} (alias \texttt{stacked\_bar}) --- SVG stacked
bar chart. Args: labels, series (array of arrays) {[}, title{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{stacked\_bar\_svg(["Q1","Q2","Q3"], [[10,20,30],[5,15,25]], "Revenue") |\textgreater{} to\_file("stacked.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wordcloud\_svg}}{wordcloud\_svg}}\label{wordcloud_svg}

\texttt{wordcloud\_svg} (aliases \texttt{wordcloud}, \texttt{wcloud})
--- SVG word cloud from frequency hashref. Word size scales with
frequency.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\{rust =\textgreater{} 50, go =\textgreater{} 30, python =\textgreater{} 40\} |\textgreater{} wordcloud("Languages") |\textgreater{} to\_file("cloud.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{treemap\_svg}}{treemap\_svg}}\label{treemap_svg}

\texttt{treemap\_svg} (alias \texttt{treemap}) --- SVG treemap from
frequency hashref. Area proportional to values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\{src =\textgreater{} 500, tests =\textgreater{} 200, docs =\textgreater{} 100\} |\textgreater{} treemap("Codebase") |\textgreater{} to\_file("tree.svg")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{preview}}{preview}}\label{preview}

\texttt{preview} (alias \texttt{pvw}) --- wrap SVG/HTML content in a
cyberpunk-styled page and open in the default browser.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{scatter\_svg([1,2,3], [1,4,9]) |\textgreater{} preview}
\NormalTok{bar\_svg(["A","B"], [10,20]) |\textgreater{} pvw}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-audio}
\chapter{Audio}\label{audio}

4 topics

\section{\texorpdfstring{\texttt{audio\_convert}}{audio\_convert}}\label{audio_convert}

\texttt{audio\_convert} (alias \texttt{aconv}) --- convert audio files
between WAV, FLAC, AIFF, and MP3 formats.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{audio\_convert("song.flac", "song.mp3")}
\NormalTok{aconv("input.wav", "output.mp3")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{audio\_info}}{audio\_info}}\label{audio_info}

\texttt{audio\_info} (alias \texttt{ainfo}) --- get audio file metadata
(duration, sample rate, channels, format) as a hashref.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $info = ainfo("song.mp3")}
\NormalTok{p $info{-}\textgreater{}\{duration\}      \# seconds}
\NormalTok{p $info{-}\textgreater{}\{sample\_rate\}   \# e.g. 44100}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{id3\_read}}{id3\_read}}\label{id3_read}

\texttt{id3\_read} (alias \texttt{id3}) --- read ID3 tags from an MP3
file as a hashref (title, artist, album, year, etc.).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $tags = id3("song.mp3")}
\NormalTok{p "$tags{-}\textgreater{}\{artist\} {-} $tags{-}\textgreater{}\{title\}"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{id3\_write}}{id3\_write}}\label{id3_write}

\texttt{id3\_write} (alias \texttt{id3w}) --- write ID3 tags to an MP3
file from a hashref.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{id3w("song.mp3", \{title =\textgreater{} "New Title", artist =\textgreater{} "Artist", year =\textgreater{} "2026"\})}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-network-utilities}
\chapter{Network Utilities}\label{network-utilities}

18 topics

\section{\texorpdfstring{\texttt{net\_interfaces}}{net\_interfaces}}\label{net_interfaces}

\texttt{net\_interfaces} (aliases \texttt{net\_ifs}, \texttt{ifconfig})
--- list all network interfaces with name, IPs, MAC, and status.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @ifs = net\_ifs()}
\NormalTok{for (@ifs) \{ p "\_{-}\textgreater{}\{name\}: \_{-}\textgreater{}\{ipv4\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_ipv4}}{net\_ipv4}}\label{net_ipv4}

\texttt{net\_ipv4} (aliases \texttt{myip}, \texttt{myip4}) --- return
the first non-loopback IPv4 address as a string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p myip()   \# e.g. 192.168.1.42}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_ipv6}}{net\_ipv6}}\label{net_ipv6}

\texttt{net\_ipv6} (alias \texttt{myip6}) --- return the first
non-loopback IPv6 address as a string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p myip6()   \# e.g. fe80::1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_mac}}{net\_mac}}\label{net_mac}

\texttt{net\_mac} (alias \texttt{mymac}) --- return the first
non-loopback MAC address.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mymac()   \# e.g. aa:bb:cc:dd:ee:ff}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_public\_ip}}{net\_public\_ip}}\label{net_public_ip}

\texttt{net\_public\_ip} (aliases \texttt{pubip}, \texttt{extip}) ---
fetch your public IP address via HTTP.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pubip()   \# e.g. 203.0.113.42}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_dns}}{net\_dns}}\label{net_dns}

\texttt{net\_dns} (aliases \texttt{dns\_resolve}, \texttt{resolve}) ---
resolve a hostname to IP addresses.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @ips = resolve("github.com")}
\NormalTok{p @ips}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_reverse\_dns}}{net\_reverse\_dns}}\label{net_reverse_dns}

\texttt{net\_reverse\_dns} (alias \texttt{rdns}) --- reverse DNS lookup
via UDP PTR query.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p rdns("8.8.8.8")   \# dns.google}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_ping}}{net\_ping}}\label{net_ping}

\texttt{net\_ping} (alias \texttt{ping}) --- TCP connect ping to
host:port. Returns array of RTT measurements in ms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @rtt = ping("google.com", 443, 5)   \# 5 pings}
\NormalTok{p mean(@rtt)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_port\_open}}{net\_port\_open}}\label{net_port_open}

\texttt{net\_port\_open} (alias \texttt{port\_open}) --- check if a TCP
port is open on a host. Returns boolean.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p port\_open("localhost", 8080)   \# 1 or 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_ports\_scan}}{net\_ports\_scan}}\label{net_ports_scan}

\texttt{net\_ports\_scan} (aliases \texttt{port\_scan},
\texttt{portscan}) --- scan a range of TCP ports on a host. Returns list
of open ports.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @open = port\_scan("localhost", 80, 443)}
\NormalTok{p @open   \# e.g. 80, 443}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_latency}}{net\_latency}}\label{net_latency}

\texttt{net\_latency} (alias \texttt{tcplat}) --- measure TCP connect
latency to host:port in milliseconds.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p tcplat("google.com", 443)   \# e.g. 12.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_download}}{net\_download}}\label{net_download}

\texttt{net\_download} (aliases \texttt{download}, \texttt{wget}) ---
download a URL to a local file via ureq.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{wget("https://example.com/data.csv", "data.csv")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_headers}}{net\_headers}}\label{net_headers}

\texttt{net\_headers} (alias \texttt{http\_headers}) --- fetch HTTP
response headers as a hashref.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $h = http\_headers("https://example.com")}
\NormalTok{p $h{-}\textgreater{}\{"content{-}type"\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_dns\_servers}}{net\_dns\_servers}}\label{net_dns_servers}

\texttt{net\_dns\_servers} (alias \texttt{dns\_servers}) --- return the
system\textquotesingle s configured DNS server addresses.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @dns = dns\_servers()}
\NormalTok{p @dns   \# e.g. 8.8.8.8, 8.8.4.4}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_gateway}}{net\_gateway}}\label{net_gateway}

\texttt{net\_gateway} (alias \texttt{gateway}) --- return the default
gateway IP address.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gateway()   \# e.g. 192.168.1.1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_whois}}{net\_whois}}\label{net_whois}

\texttt{net\_whois} (alias \texttt{whois}) --- WHOIS lookup via raw TCP
connection on port 43.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p whois("example.com")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_hostname}}{net\_hostname}}\label{net_hostname}

\texttt{net\_hostname} --- return the system hostname.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p net\_hostname()   \# e.g. my{-}macbook.local}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smtp\_send}}{smtp\_send}}\label{smtp_send}

\texttt{smtp\_send} (aliases \texttt{send\_email}, \texttt{email}) ---
send an email via SMTP with TLS. Takes a hashref with to, from, subject,
body, and SMTP connection fields.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{smtp\_send(\{to =\textgreater{} "bob@ex.com", from =\textgreater{} "me@ex.com", subject =\textgreater{} "Hi",}
\NormalTok{  body =\textgreater{} "Hello!", smtp\_host =\textgreater{} "smtp.ex.com", smtp\_port =\textgreater{} 587,}
\NormalTok{  smtp\_user =\textgreater{} "me@ex.com", smtp\_pass =\textgreater{} $pass\})}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-markup-web-scraping}
\chapter{Markup / Web Scraping}\label{markup-web-scraping}

4 topics

\section{\texorpdfstring{\texttt{html\_parse}}{html\_parse}}\label{html_parse}

\texttt{html\_parse} (alias \texttt{parse\_html}) --- parse an HTML
string into an array of element hashrefs with tag, text, and attrs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @els = html\_parse(slurp("page.html"))}
\NormalTok{for (@els) \{ p "\_{-}\textgreater{}\{tag\}: \_{-}\textgreater{}\{text\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{css\_select}}{css\_select}}\label{css_select}

\texttt{css\_select} (aliases \texttt{css}, \texttt{qs},
\texttt{query\_selector}) --- query parsed HTML with a CSS selector.
Returns matching elements as hashrefs with tag, text, attrs, and html.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @links = css\_select(slurp("page.html"), "a.nav")}
\NormalTok{for (@links) \{ p "\_{-}\textgreater{}\{tag\} \_{-}\textgreater{}\{attrs\}\{href\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xml\_parse}}{xml\_parse}}\label{xml_parse}

\texttt{xml\_parse} (alias \texttt{parse\_xml}) --- parse an XML string
into a nested hashref tree with tag, text, attrs, and children.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $root = xml\_parse(slurp("data.xml"))}
\NormalTok{p $root{-}\textgreater{}\{tag\}}
\NormalTok{for (@\{$root{-}\textgreater{}\{children\}\}) \{ p \_{-}\textgreater{}\{text\} \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xpath}}{xpath}}\label{xpath}

\texttt{xpath} (alias \texttt{xml\_select}) --- query XML with
XPath-like expressions (//tag,
//tag{[}@attr=\textquotesingle val\textquotesingle{]}). Returns matching
nodes as hashrefs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @items = xpath(slurp("feed.xml"), "//item")}
\NormalTok{for (@items) \{ p \_{-}\textgreater{}\{text\} \}}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-date-utilities}
\chapter{Date Utilities}\label{date-utilities}

4 topics

\section{\texorpdfstring{\texttt{dateseq}}{dateseq}}\label{dateseq}

\texttt{dateseq} (alias \texttt{dseq}) --- generate a sequence of dates.
Args: start, end {[}, step{]}. Step defaults to 1 day.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @days = dseq("2026{-}01{-}01", "2026{-}01{-}07")}
\NormalTok{p @days}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dategrep}}{dategrep}}\label{dategrep}

\texttt{dategrep} (alias \texttt{dgrep}) --- filter a list of date
strings by a pattern or range.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @jan = dgrep("2026{-}01", @dates)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dateround}}{dateround}}\label{dateround}

\texttt{dateround} (alias \texttt{dround}) --- round date strings to a
unit (day, hour, month, etc.).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dround("2026{-}04{-}19T14:35:22", "hour")   \# 2026{-}04{-}19T15:00:00}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{datesort}}{datesort}}\label{datesort}

\texttt{datesort} (alias \texttt{dsort}) --- sort date strings
chronologically.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @sorted = dsort("2026{-}03{-}01", "2026{-}01{-}15", "2026{-}02{-}10")}
\NormalTok{p @sorted}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-git}
\chapter{Git}\label{git}

10 topics

\section{\texorpdfstring{\texttt{git\_log}}{git\_log}}\label{git_log}

\texttt{git\_log} (alias \texttt{glog}) --- get the last N commits as an
array of hashrefs (hash, author, date, message).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @commits = glog(10)}
\NormalTok{for (@commits) \{ p "\_{-}\textgreater{}\{hash\} \_{-}\textgreater{}\{message\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_status}}{git\_status}}\label{git_status}

\texttt{git\_status} (alias \texttt{gst}) --- get working tree status as
an array of hashrefs (path, status).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @st = gst()}
\NormalTok{for (@st) \{ p "\_{-}\textgreater{}\{status\} \_{-}\textgreater{}\{path\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_diff}}{git\_diff}}\label{git_diff}

\texttt{git\_diff} (alias \texttt{gdiff}) --- get the current diff as a
string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gdiff()}
\NormalTok{gdiff() |\textgreater{} lines |\textgreater{} grep /\^{}\textbackslash{}+/ |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_branches}}{git\_branches}}\label{git_branches}

\texttt{git\_branches} (alias \texttt{gbr}) --- list all branches as an
array of strings.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @br = gbr()}
\NormalTok{p @br}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_tags}}{git\_tags}}\label{git_tags}

\texttt{git\_tags} (alias \texttt{gtags}) --- list all tags as an array
of strings.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @tags = gtags()}
\NormalTok{p @tags}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_blame}}{git\_blame}}\label{git_blame}

\texttt{git\_blame} (alias \texttt{gblame}) --- blame a file, returning
per-line annotation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gblame("src/main.rs")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_authors}}{git\_authors}}\label{git_authors}

\texttt{git\_authors} (alias \texttt{gauthors}) --- list unique authors
sorted by commit count as hashrefs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @authors = gauthors()}
\NormalTok{for (@authors) \{ p "\_{-}\textgreater{}\{name\}: \_{-}\textgreater{}\{count\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_files}}{git\_files}}\label{git_files}

\texttt{git\_files} (alias \texttt{gfiles}) --- list all tracked files
in the repo.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @files = gfiles()}
\NormalTok{p scalar @files   \# total tracked files}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_show}}{git\_show}}\label{git_show}

\texttt{git\_show} (alias \texttt{gshow}) --- show details of a commit
(message, diff, author).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gshow("HEAD")}
\NormalTok{p gshow("abc1234")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{git\_root}}{git\_root}}\label{git_root}

\texttt{git\_root} (alias \texttt{groot}) --- return the repository root
path.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p groot()   \# e.g. /home/user/project}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-system}
\chapter{System}\label{system-1}

13 topics

\section{\texorpdfstring{\texttt{mounts}}{mounts}}\label{mounts}

\texttt{mounts} (aliases \texttt{disk\_mounts}, \texttt{filesystems})
--- list mounted filesystems with usage (total, used, available).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @m = mounts()}
\NormalTok{for (@m) \{ p "\_{-}\textgreater{}\{mount\}: \_{-}\textgreater{}\{used\}/\_{-}\textgreater{}\{total\}" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thread\_count}}{thread\_count}}\label{thread_count}

\texttt{thread\_count} (alias \texttt{nthreads}) --- return the rayon
thread pool size.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p nthreads()   \# e.g. 8}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pool\_info}}{pool\_info}}\label{pool_info}

\texttt{pool\_info} (alias \texttt{par\_info}) --- return thread pool
details as a hashref (threads, queued, active).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $info = par\_info()}
\NormalTok{p $info{-}\textgreater{}\{threads\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{par\_bench}}{par\_bench}}\label{par_bench}

\texttt{par\_bench} (alias \texttt{pbench}) --- run a parallel
throughput benchmark and return results.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pbench(1000000)}
\NormalTok{p $result{-}\textgreater{}\{ops\_per\_sec\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_pdf}}{to\_pdf}}\label{to_pdf}

\texttt{to\_pdf} --- generate a PDF from text, SVG, or structured data.
Returns raw PDF bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{"Hello World" |\textgreater{} to\_pdf |\textgreater{} to\_file("out.pdf")}
\NormalTok{scatter\_svg([1,2,3], [1,4,9]) |\textgreater{} to\_pdf |\textgreater{} to\_file("plot.pdf")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pdf\_text}}{pdf\_text}}\label{pdf_text}

\texttt{pdf\_text} (aliases \texttt{pdf\_read}, \texttt{pdf\_extract})
--- extract all text content from a PDF file and return it as a string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $text = pdf\_text("report.pdf")}
\NormalTok{p $text |\textgreater{} lines |\textgreater{} cnt   \# number of lines}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pdf\_pages}}{pdf\_pages}}\label{pdf_pages}

\texttt{pdf\_pages} --- return the number of pages in a PDF file.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pdf\_pages("report.pdf")   \# e.g. 42}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jq}}{jq}}\label{jq}

\texttt{jq} --- alias for \texttt{json\_jq}. Query JSON data with
jq-style expressions.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $data = json\_decode(slurp("data.json"))}
\NormalTok{p jq($data, ".items[].name")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_cpu}}{stress\_cpu}}\label{stress_cpu}

\texttt{stress\_cpu} (alias \texttt{scpu}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $hashes = stress\_cpu(10)   \# 10 seconds of CPU stress}
\NormalTok{p "Computed $hashes hashes"}

\NormalTok{\# Distributed across cluster}
\NormalTok{my $c = cluster(["node1:8", "node2:8"])}
\NormalTok{1:16 |\textgreater{} pmap\_on $c \{ stress\_cpu(60) \}   \# 60s stress on all workers}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_mem}}{stress\_mem}}\label{stress_mem}

\texttt{stress\_mem} (alias \texttt{smem}) --- Memory stress test:
allocate and touch the specified number of bytes (default 100MB).
Returns bytes allocated. Use for memory pressure testing and OOM
validation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $bytes = stress\_mem(1e9)   \# Allocate 1GB}
\NormalTok{p "Allocated $bytes bytes"}

\NormalTok{\# Memory pressure across cluster}
\NormalTok{1:16 |\textgreater{} pmap\_on $cluster \{ stress\_mem(4e9) \}   \# 4GB per worker}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_io}}{stress\_io}}\label{stress_io}

\texttt{stress\_io} (alias \texttt{sio}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $bytes = stress\_io("/tmp", 1000)   \# 1000 iterations}
\NormalTok{p "Wrote $bytes bytes"}

\NormalTok{\# IO stress across cluster}
\NormalTok{1:16 |\textgreater{} pmap\_on $cluster \{ stress\_io("/data", 500) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_test}}{stress\_test}}\label{stress_test}

\texttt{stress\_test} (alias \texttt{st}) --- 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\}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# Local stress test (10 seconds)}
\NormalTok{my $r = stress\_test(10)}
\NormalTok{p "CPU: $r{-}\textgreater{}\{cpu\_hashes\}, Workers: $r{-}\textgreater{}\{workers\}"}

\NormalTok{\# Distributed stress test}
\NormalTok{my $c = cluster(["node1:8", "node2:8", "node3:8"])}
\NormalTok{my $r = stress\_test($c, 60)   \# 60s across 24 workers}
\NormalTok{p "Hashes: $r{-}\textgreater{}\{cpu\_hashes\}, Duration: $r{-}\textgreater{}\{duration\}s"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heat}}{heat}}\label{heat}

\texttt{heat} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{heat(60)     \# 60 seconds of maximum heat}
\NormalTok{heat()       \# default 60 seconds}

\NormalTok{\# Output:}
\NormalTok{\# 🔥 HEAT: Pinning N cores to 100\% TDP for 60s}
\NormalTok{\# 🔥 HEAT: 3,116,320,000 hashes in 60.00s (51.9M/s across N cores)}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-testing}
\chapter{Testing}\label{testing}

15 topics

\section{\texorpdfstring{\texttt{assert\_eq}}{assert\_eq}}\label{assert_eq}

\texttt{assert\_eq} (alias \texttt{aeq}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_eq $got, $expected, "username matches"}
\NormalTok{aeq length(@arr), 3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_ne}}{assert\_ne}}\label{assert_ne}

\texttt{assert\_ne} (alias \texttt{ane}) --- assert that two values are
not equal as strings. Takes A, B, and an optional message. Fails if A eq
B.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_ne $token, "", "token must not be empty"}
\NormalTok{ane $a, $b}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_ok}}{assert\_ok}}\label{assert_ok}

\texttt{assert\_ok} (alias \texttt{aok}) --- assert that a value is
truthy (defined and non-zero/non-empty). Fails if the value is falsy or
undef.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_ok $result, "fetch returned data"}
\NormalTok{aok $user{-}\textgreater{}\{active\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_err}}{assert\_err}}\label{assert_err}

\texttt{assert\_err} --- assert that a value is falsy or undef. The
inverse of \texttt{assert\_ok}. Useful for verifying error conditions or
absent values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_err $deleted\_user, "user should be gone"}
\NormalTok{assert\_err 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_true}}{assert\_true}}\label{assert_true}

\texttt{assert\_true} (alias \texttt{atrue}) --- alias for
\texttt{assert\_ok}. Assert that a value is truthy.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_true $connected, "should be connected"}
\NormalTok{atrue $flag}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_false}}{assert\_false}}\label{assert_false}

\texttt{assert\_false} (alias \texttt{afalse}) --- alias for
\texttt{assert\_err}. Assert that a value is falsy or undef.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_false $error, "no error expected"}
\NormalTok{afalse $disabled}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_gt}}{assert\_gt}}\label{assert_gt}

\texttt{assert\_gt} --- assert that the first numeric value is strictly
greater than the second. Fails with the actual values on mismatch.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_gt $elapsed, 0, "elapsed must be positive"}
\NormalTok{assert\_gt scalar(@results), 10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_lt}}{assert\_lt}}\label{assert_lt}

\texttt{assert\_lt} --- assert that the first numeric value is strictly
less than the second.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_lt $latency, 100, "latency under 100ms"}
\NormalTok{assert\_lt $errors, $threshold}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_ge}}{assert\_ge}}\label{assert_ge}

\texttt{assert\_ge} --- assert that the first numeric value is greater
than or equal to the second.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_ge $count, 1, "at least one result"}
\NormalTok{assert\_ge $version, 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_le}}{assert\_le}}\label{assert_le}

\texttt{assert\_le} --- assert that the first numeric value is less than
or equal to the second.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_le $memory, $limit, "within memory budget"}
\NormalTok{assert\_le length($buf), 4096}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_match}}{assert\_match}}\label{assert_match}

\texttt{assert\_match} (alias \texttt{amatch}) --- assert that a string
matches a regex pattern. Fails with the actual string and pattern on
mismatch.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_match $email, qr/\textbackslash{}@/, "must contain @"}
\NormalTok{amatch $line, qr/\^{}OK/}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_contains}}{assert\_contains}}\label{assert_contains}

\texttt{assert\_contains} (alias \texttt{acontains}) --- assert that a
string contains a given substring. Fails with both values on mismatch.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_contains $html, "\textless{}title\textgreater{}", "page has title"}
\NormalTok{acontains $log, "SUCCESS"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_near}}{assert\_near}}\label{assert_near}

\texttt{assert\_near} (alias \texttt{anear}) --- assert that two floats
are approximately equal within an epsilon tolerance (default 1e-9).
Essential for floating-point comparisons.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_near 0.1 + 0.2, 0.3, 1e{-}10, "float add"}
\NormalTok{anear $pi, 3.14159, 1e{-}5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_dies}}{assert\_dies}}\label{assert_dies}

\texttt{assert\_dies} (alias \texttt{adies}) --- assert that a block
throws an error. Passes if the block dies, fails if it returns normally.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{assert\_dies \{ die "boom" \} "should throw"}
\NormalTok{adies \{ 1 / 0 \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{test\_run}}{test\_run}}\label{test_run}

\texttt{test\_run} (alias \texttt{run\_tests}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# ... assertions above ...}
\NormalTok{test\_run   \# prints summary, exits 1 on failure}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-test-runner-worker-pool}
\chapter{Test Runner (worker pool)}\label{test-runner-worker-pool}

4 topics

\section{\texorpdfstring{\texttt{test}}{test}}\label{test}

\texttt{test(FILE\_OR\_DIR,\ ...)} --- run every \texttt{test\_*.stk} /
\texttt{t\_*.stk} under each path through the \textbf{worker pool}. Same
engine as \texttt{s\ t} on the CLI: pre-forks N persistent stryke
\texttt{-\/-test-worker} processes, dispatches paths via JSON over
stdin/stdout, each worker \texttt{fork()}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:
\texttt{\{\ fork\ =\textgreater{}\ 1\ \}} for the legacy
\texttt{posix\_spawn}-per-test path,
\texttt{\{\ inproc\ =\textgreater{}\ 1\ \}} for single-process
VM-per-test (fastest, hermetic only),
\texttt{\{\ quiet\ =\textgreater{}\ 1\ \}},
\texttt{\{\ no\_interop\ =\textgreater{}\ 1\ \}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{test("t/")                                \# default: worker pool}
\NormalTok{test(["t/", "examples/"], \{ quiet =\textgreater{} 1 \})}
\NormalTok{test("t/test\_foo.stk", \{ fork =\textgreater{} 1 \})     \# opt back into per{-}test fork}
\NormalTok{my $rc = test(@dirs)                      \# array flattens; rc = 0/1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{test\_no\_interop}}{test\_no\_interop}}\label{test_no_interop}

\texttt{test\_no\_interop(FILE\_OR\_DIR,\ ...)} (alias
\texttt{test\_ni}) --- same as \texttt{test}, but pins each worker
thread\textquotesingle s TLS no-interop flag for the duration of the
test (\texttt{set\_no\_interop\_mode\_tls}). Sibling \texttt{pmaps}
workers don\textquotesingle t race on a shared atomic. Forwards
\texttt{-\/-no-interop} to every spawned grandchild so each test runs
under stryke\textquotesingle s bot-firewall mode (rejects Perl-isms,
forces stryke idioms).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{test\_no\_interop("t/")}
\NormalTok{test\_ni(["t/a", "t/b"], \{ quiet =\textgreater{} 1 \})}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{check}}{check}}\label{check}

\texttt{check(FILE,\ ...)} --- in-process equivalent of
\texttt{stryke\ check\ FILE...}. Parses, compiles, and lints each path
without executing it. Returns the exit code (0 on success, 1 on errors).
Optional trailing hashref: \texttt{\{\ quiet\ =\textgreater{}\ 1\ \}},
\texttt{\{\ json\ =\textgreater{}\ 1\ \}},
\texttt{\{\ no\_interop\ =\textgreater{}\ 1\ \}}.

Faster than \texttt{system\ "stryke\ check\ \$f"} because it skips the
binary fork and reuses the parent process\textquotesingle s
parser/compiler. The lint pass is \textbf{not} a strict-vars enforcer
--- undefined-variable errors only fire on files that themselves do
\texttt{use\ strict;}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $rc = check("foo.stk")                    \# 0 = ok, 1 = errors}
\NormalTok{check(\textbackslash{}@files, \{ quiet =\textgreater{} 1 \})               \# arrayref + opts}
\NormalTok{for my $f (glob("src/*.stk")) \{ check($f) or warn "$f failed" \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{check\_no\_interop}}{check\_no\_interop}}\label{check_no_interop}

\texttt{check\_no\_interop(FILE,\ ...)} (alias \texttt{check\_ni}) ---
same as \texttt{check}, but pins \textbf{this thread} to
\texttt{-\/-no-interop} 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 \texttt{pmaps} workers in parallel ---
no global-atomic race.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{check\_no\_interop("foo.stk")                  \# rejects sub/say/$a/$b}
\NormalTok{pmaps \{ check\_ni(\_, \{ quiet =\textgreater{} 1 \}) \} @files \# parallel{-}safe, no race}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-ai-primitives-docs-ai-primitives-md}
\chapter{AI primitives
(docs/AI\_PRIMITIVES.md)}\label{ai-primitives-docsai_primitives.md}

79 topics

\section{\texorpdfstring{\texttt{ai}}{ai}}\label{ai}

\texttt{ai\ \$prompt,\ opts...} --- single-shot LLM call (or auto-routes
to the agent loop when
\texttt{tools\ =\textgreater{}\ {[}...{]}}/\texttt{tool\ fn}s are in
scope, vision when
\texttt{image\ =\textgreater{}\ \$url\textbar{}\$path}, structured
output when \texttt{schema\ =\textgreater{}\ +\{...\}}, document input
when \texttt{pdf\ =\textgreater{}\ \$path}).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $r = ai "summarize this", $document}
\NormalTok{my $r = ai "weather in SF"   \# auto{-}uses any \textasciigrave{}tool fn\textasciigrave{} defined in scope}
\NormalTok{my $r = ai "describe", image =\textgreater{} "/photo.jpg"}
\NormalTok{my $r = ai "extract user", schema =\textgreater{} +\{ name =\textgreater{} "string", age =\textgreater{} "int" \}}
\end{Highlighting}
\end{Shaded}

Providers: anthropic (default), openai. Mock with
\texttt{ai\_mock\_install}. Cost via \texttt{ai\_cost}.

\section{\texorpdfstring{\texttt{stream\_prompt}}{stream\_prompt}}\label{stream_prompt}

\texttt{stream\_prompt\ \$prompt,\ on\_chunk\ =\textgreater{}\ sub\ \{\ ...\ \}}
--- Anthropic SSE streaming. With \texttt{on\_chunk}, fires once per
text-delta. Without, returns a \texttt{PerlIterator}-backed handle:
\texttt{for\ my\ \$chunk\ in\ stream\_prompt("...")\ \{\ print\ \$chunk\ \}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $state = +\{ buf =\textgreater{} "" \};}
\NormalTok{stream\_prompt("write a haiku",}
\NormalTok{    on\_chunk =\textgreater{} sub \{ $state{-}\textgreater{}\{buf\} .= $\_[0]; print $\_[0] \});}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chat}}{chat}}\label{chat}

\texttt{chat\ \textbackslash{}@messages,\ opts...} --- explicit
message-list call. Each entry is
\texttt{+\{role\ =\textgreater{}\ "user"\textbar{}"assistant"\textbar{}"system",\ content\ =\textgreater{}\ ...\}}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{chat([}
\NormalTok{    +\{ role =\textgreater{} "system", content =\textgreater{} "Be concise" \},}
\NormalTok{    +\{ role =\textgreater{} "user",   content =\textgreater{} "hi" \},}
\NormalTok{])}
\end{Highlighting}
\end{Shaded}

For multi-turn with auto-tracking, use \texttt{ai\_session\_*} instead.

\section{\texorpdfstring{\texttt{embed}}{embed}}\label{embed}

\texttt{embed\ \$text} or \texttt{embed\ \textbackslash{}@texts} ---
vector embedding via Voyage AI (default) or OpenAI. Returns arrayref of
floats (single text) or arrayref-of-arrayref (batch). Routes via
\texttt{ai\_routing\_set("embed",\ ...)}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @vec = @\{ embed("hello world") \}}
\NormalTok{my @vecs = @\{ embed(["a", "b", "c"]) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tokens\_of}}{tokens\_of}}\label{tokens_of}

\texttt{tokens\_of} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tokens\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tokens\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_estimate}}{ai\_estimate}}\label{ai_estimate}

\texttt{ai\_estimate} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_cost}}{ai\_cost}}\label{ai_cost}

\texttt{ai\_cost()} --- running spend / token / cache stats hashref:
\texttt{+\{usd,\ input\_tokens,\ output\_tokens,\ embed\_tokens,\ cache\_creation\_tokens,\ cache\_read\_tokens,\ cache\_hits,\ cache\_misses\}}.

\section{\texorpdfstring{\texttt{ai\_history}}{ai\_history}}\label{ai_history}

\texttt{ai\_history} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_history $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_history |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_history\_clear}}{ai\_history\_clear}}\label{ai_history_clear}

\texttt{ai\_history\_clear} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_history\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_history\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_cache\_clear}}{ai\_cache\_clear}}\label{ai_cache_clear}

\texttt{ai\_cache\_clear} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_cache\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_cache\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_cache\_size}}{ai\_cache\_size}}\label{ai_cache_size}

\texttt{ai\_cache\_size} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_cache\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_cache\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_mock\_install}}{ai\_mock\_install}}\label{ai_mock_install}

\texttt{ai\_mock\_install} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_mock\_install $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_mock\_install |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_mock\_clear}}{ai\_mock\_clear}}\label{ai_mock_clear}

\texttt{ai\_mock\_clear} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_mock\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_mock\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_config\_get}}{ai\_config\_get}}\label{ai_config_get}

\texttt{ai\_config\_get} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_config\_get $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_config\_get |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_config\_set}}{ai\_config\_set}}\label{ai_config_set}

\texttt{ai\_config\_set} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_config\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_config\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_routing\_get}}{ai\_routing\_get}}\label{ai_routing_get}

\texttt{ai\_routing\_get} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_routing\_get $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_routing\_get |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_routing\_set}}{ai\_routing\_set}}\label{ai_routing_set}

\texttt{ai\_routing\_set} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_routing\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_routing\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_register\_tool}}{ai\_register\_tool}}\label{ai_register_tool}

\texttt{ai\_register\_tool(\$name,\ \$description,\ +\{params\},\ sub\ \{\ ...\ \})}
--- register a tool that the bare \texttt{ai(\$prompt)} call
auto-attaches to its agent loop. Idempotent re-register on same name.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{ai\_register\_tool("weather", "Get weather",}
\NormalTok{    +\{ city =\textgreater{} "string" \},}
\NormalTok{    sub \{ fetch "https://api.weather.com/" . uri\_encode($\_[0]{-}\textgreater{}\{city\}) \});}
\NormalTok{ai\_clear\_tools();}
\end{Highlighting}
\end{Shaded}

For parser-level sugar, use \texttt{tool\ fn} instead.

\section{\texorpdfstring{\texttt{ai\_unregister\_tool}}{ai\_unregister\_tool}}\label{ai_unregister_tool}

\texttt{ai\_unregister\_tool} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_unregister\_tool $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_unregister\_tool |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_clear\_tools}}{ai\_clear\_tools}}\label{ai_clear_tools}

\texttt{ai\_clear\_tools} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_clear\_tools $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_clear\_tools |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_tools\_list}}{ai\_tools\_list}}\label{ai_tools_list}

\texttt{ai\_tools\_list} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_tools\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_tools\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_filter}}{ai\_filter}}\label{ai_filter}

\texttt{ai\_filter\ \textbackslash{}@items,\ "criterion"} --- keep items
the model judges as matching the criterion. Single batched LLM call;
cheap by construction.

\section{\texorpdfstring{\texttt{ai\_map}}{ai\_map}}\label{ai_map}

\texttt{ai\_map\ \textbackslash{}@items,\ "instruction"} --- apply
instruction to each item, single batched LLM call. Returns arrayref of
strings.

\section{\texorpdfstring{\texttt{ai\_classify}}{ai\_classify}}\label{ai_classify}

\texttt{ai\_classify\ \textbackslash{}@items,\ "hint",\ into\ =\textgreater{}\ {[}"a",\ "b",\ "c"{]}}
--- assign one of the labels to each item.

\section{\texorpdfstring{\texttt{ai\_match}}{ai\_match}}\label{ai_match}

\texttt{ai\_match} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_sort}}{ai\_sort}}\label{ai_sort}

\texttt{ai\_sort} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_sort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_sort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_dedupe}}{ai\_dedupe}}\label{ai_dedupe}

\texttt{ai\_dedupe} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_dedupe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_dedupe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_extract}}{ai\_extract}}\label{ai_extract}

\texttt{ai\_extract\ "prompt",\ schema\ =\textgreater{}\ +\{\ name\ =\textgreater{}\ "string",\ age\ =\textgreater{}\ "int"\ \}}
--- structured JSON output; returns a typed hashref.

\section{\texorpdfstring{\texttt{ai\_summarize}}{ai\_summarize}}\label{ai_summarize}

\texttt{ai\_summarize\ \$text,\ words\ =\textgreater{}\ 50} ---
convenience wrapper that asks the model for a concise summary at target
length.

\section{\texorpdfstring{\texttt{ai\_translate}}{ai\_translate}}\label{ai_translate}

\texttt{ai\_translate\ \$text,\ to\ =\textgreater{}\ "Spanish"} ---
convenience wrapper for translation.

\section{\texorpdfstring{\texttt{ai\_template}}{ai\_template}}\label{ai_template}

\texttt{ai\_template\ "hi\ \{name\}",\ name\ =\textgreater{}\ "world"}
--- pure string substitution. \texttt{\{\{} escapes to a literal
\texttt{\{}. Missing keys pass through unchanged.

\section{\texorpdfstring{\texttt{ai\_transcribe}}{ai\_transcribe}}\label{ai_transcribe}

\texttt{ai\_transcribe\ "audio.mp3",\ model\ =\textgreater{}\ "whisper-1",\ language\ =\textgreater{}\ "en"}
--- OpenAI Whisper transcription. Multipart upload to
\texttt{/v1/audio/transcriptions}. Returns the transcript string.
Defaults to \texttt{whisper-1}.

\section{\texorpdfstring{\texttt{ai\_speak}}{ai\_speak}}\label{ai_speak}

\texttt{ai\_speak\ \$text,\ voice\ =\textgreater{}\ "alloy",\ model\ =\textgreater{}\ "tts-1",\ format\ =\textgreater{}\ "mp3",\ output\ =\textgreater{}\ "out.mp3"}
--- OpenAI TTS. Returns raw audio bytes; pass
\texttt{output\ =\textgreater{}} to also write to disk. Voices: alloy,
echo, fable, onyx, nova, shimmer.

\section{\texorpdfstring{\texttt{ai\_image}}{ai\_image}}\label{ai_image}

\texttt{ai\_image\ \$prompt,\ model\ =\textgreater{}\ "dall-e-3",\ size\ =\textgreater{}\ "1024x1024",\ quality\ =\textgreater{}\ "hd",\ output\ =\textgreater{}\ "out.png",\ n\ =\textgreater{}\ 1}
--- image generation (OpenAI Images). Returns raw PNG bytes for n=1, or
arrayref of bytes for n\textgreater1. Models: \texttt{dall-e-3},
\texttt{gpt-image-1}. \texttt{output} writes to disk (with
\texttt{\_1}/\texttt{\_2}/... suffix for n\textgreater1).

\section{\texorpdfstring{\texttt{ai\_image\_edit}}{ai\_image\_edit}}\label{ai_image_edit}

\texttt{ai\_image\_edit\ \$prompt,\ image\ =\textgreater{}\ "in.png",\ mask\ =\textgreater{}\ "mask.png",\ output\ =\textgreater{}\ "out.png"}
--- image-to-image edit via OpenAI \texttt{/v1/images/edits}. Optional
mask is a PNG with transparent regions marking where to edit. Returns
PNG bytes (or arrayref for \texttt{n\textgreater{}1}).

\section{\texorpdfstring{\texttt{ai\_image\_variation}}{ai\_image\_variation}}\label{ai_image_variation}

\texttt{ai\_image\_variation\ image\ =\textgreater{}\ "in.png",\ n\ =\textgreater{}\ 4,\ size\ =\textgreater{}\ "1024x1024"}
--- generate variations of an existing image (OpenAI
\texttt{/v1/images/variations}, DALL-E 2). Returns PNG bytes for
\texttt{n=1} or arrayref for \texttt{n\textgreater{}1}.

\section{\texorpdfstring{\texttt{ai\_models}}{ai\_models}}\label{ai_models}

\texttt{ai\_models(\$provider)} → arrayref of model IDs from the live
catalog. Providers: \texttt{openai}, \texttt{anthropic},
\texttt{ollama}, \texttt{gemini}. Useful for tooling that surfaces the
available models without hardcoding lists.

\section{\texorpdfstring{\texttt{ai\_citations}}{ai\_citations}}\label{ai_citations}

\texttt{ai\_citations()} --- arrayref of citations from the most recent
Anthropic call (when \texttt{citations\ =\textgreater{}\ 1} was passed).
Each entry is a hashref with \texttt{text} (cited string),
\texttt{title}, \texttt{start}/\texttt{end} char offsets or
\texttt{start\_page}/\texttt{end\_page} page numbers, and
\texttt{document\_index}.

\section{\texorpdfstring{\texttt{ai\_dashboard}}{ai\_dashboard}}\label{ai_dashboard}

\texttt{ai\_dashboard()} → 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:
\texttt{print\ ai\_dashboard()}.

\section{\texorpdfstring{\texttt{ai\_pricing}}{ai\_pricing}}\label{ai_pricing}

\texttt{ai\_pricing("claude-opus-4-7")} → hashref
\texttt{+\{\ model,\ input,\ output,\ input\_per\_1m,\ output\_per\_1m\ \}}
with the per-1K-token pricing the runtime uses for cost tracking. Useful
for pre-flight cost estimates.

\section{\texorpdfstring{\texttt{ai\_describe}}{ai\_describe}}\label{ai_describe}

\texttt{ai\_describe("image.png",\ style\ =\textgreater{}\ "concise")}
--- vision wrapper that asks the model to describe an image. Styles:
\texttt{concise} (one sentence), \texttt{detailed} (paragraph),
\texttt{alt} (HTML alt-text ≤125 chars), or any custom suffix.

\section{\texorpdfstring{\texttt{ai\_grounded}}{ai\_grounded}}\label{ai_grounded}

\texttt{ai\_grounded(\$prompt,\ documents\ =\textgreater{}\ {[}@paths\_or\_strings{]},\ titles\ =\textgreater{}\ {[}@titles{]})}
--- 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 \texttt{ai\_citations()} after the call.

\section{\texorpdfstring{\texttt{ai\_moderate}}{ai\_moderate}}\label{ai_moderate}

\texttt{ai\_moderate(\$text,\ model\ =\textgreater{}\ "omni-moderation-latest")}
→ \texttt{+\{\ flagged,\ categories,\ scores\ \}}. OpenAI content-safety
classifier. Free endpoint --- no token cost. Use it before sending
user-generated content to a generative model.

\section{\texorpdfstring{\texttt{ai\_chunk}}{ai\_chunk}}\label{ai_chunk}

\texttt{ai\_chunk(\$text,\ max\_tokens\ =\textgreater{}\ 500,\ overlap\ =\textgreater{}\ 50,\ by\ =\textgreater{}\ "tokens"\textbar{}"chars"\textbar{}"sentences")}
→ arrayref of strings. Pure local logic --- no API call. Sentence mode
splits on \texttt{.!?} and greedily packs.

\section{\texorpdfstring{\texttt{ai\_warm}}{ai\_warm}}\label{ai_warm}

\texttt{ai\_warm(model\ =\textgreater{}\ ...,\ provider\ =\textgreater{}\ ...)}
→ \texttt{+\{\ ok,\ latency\_ms,\ error,\ model,\ provider\ \}}. Sends a
1-token ping so auth/network failures surface at script start instead of
mid-flow.

\section{\texorpdfstring{\texttt{ai\_compare}}{ai\_compare}}\label{ai_compare}

\texttt{ai\_compare(\$a,\ \$b,\ criteria\ =\textgreater{}\ "factual\ accuracy",\ scale\ =\textgreater{}\ 5)}
→
\texttt{+\{\ winner,\ reason,\ scores\ =\textgreater{}\ +\{a,\ b\},\ raw\ \}}.
Single-call structured comparison. \texttt{winner} is \texttt{"a"},
\texttt{"b"}, or \texttt{"tie"}.

\section{\texorpdfstring{\texttt{ai\_session\_export}}{ai\_session\_export}}\label{ai_session_export}

\texttt{ai\_session\_export(\$handle)} → JSON string capturing system,
model, provider, and full message log. Pair with
\texttt{ai\_session\_import(\$json)} to restore.

\section{\texorpdfstring{\texttt{ai\_session\_import}}{ai\_session\_import}}\label{ai_session_import}

\texttt{ai\_session\_import(\$json)} → fresh session handle hashref.
Inverse of \texttt{ai\_session\_export}. Allocates a new id and
populates the session from the JSON body.

\section{\texorpdfstring{\texttt{ai\_file\_upload}}{ai\_file\_upload}}\label{ai_file_upload}

\texttt{ai\_file\_upload("path",\ purpose\ =\textgreater{}\ "user\_data")}
→ metadata hashref with \texttt{id}, \texttt{bytes}, \texttt{filename},
\texttt{purpose}, \texttt{created\_at}. OpenAI Files API --- file\_id
can be referenced by Whisper/Vision/Batch/Assistants.

\section{\texorpdfstring{\texttt{ai\_file\_list}}{ai\_file\_list}}\label{ai_file_list}

\texttt{ai\_file\_list(purpose\ =\textgreater{}\ "...")} → arrayref of
file metadata hashrefs from \texttt{/v1/files}.

\section{\texorpdfstring{\texttt{ai\_file\_get}}{ai\_file\_get}}\label{ai_file_get}

\texttt{ai\_file\_get(\$file\_id)} → metadata hashref for a single file.

\section{\texorpdfstring{\texttt{ai\_file\_delete}}{ai\_file\_delete}}\label{ai_file_delete}

\texttt{ai\_file\_delete(\$file\_id)} → 1 if deleted, 0 otherwise.
Removes the file from OpenAI\textquotesingle s storage.

\section{\texorpdfstring{\texttt{ai\_file\_anthropic\_upload}}{ai\_file\_anthropic\_upload}}\label{ai_file_anthropic_upload}

\texttt{ai\_file\_anthropic\_upload("path/to/file.pdf")} → metadata
hashref with \texttt{id}, \texttt{filename}, \texttt{mime\_type},
\texttt{size\_bytes}, \texttt{created\_at}. Anthropic\textquotesingle s
beta \texttt{/v1/files} endpoint --- file\_id can be referenced from
batch jobs and document blocks.

\section{\texorpdfstring{\texttt{ai\_file\_anthropic\_list}}{ai\_file\_anthropic\_list}}\label{ai_file_anthropic_list}

\texttt{ai\_file\_anthropic\_list()} → arrayref of file-metadata
hashrefs from Anthropic\textquotesingle s \texttt{/v1/files}.

\section{\texorpdfstring{\texttt{ai\_file\_anthropic\_delete}}{ai\_file\_anthropic\_delete}}\label{ai_file_anthropic_delete}

\texttt{ai\_file\_anthropic\_delete(\$file\_id)} → 1 on success, 0
otherwise. Removes the file from Anthropic\textquotesingle s storage.

\section{\texorpdfstring{\texttt{ai\_session\_new}}{ai\_session\_new}}\label{ai_session_new}

\texttt{ai\_session\_new(system\ =\textgreater{}\ "...",\ model\ =\textgreater{}\ "...")}
--- start a multi-turn chat session. Use
\texttt{ai\_session\_send(\$s,\ "msg")} to advance,
\texttt{ai\_session\_history(\$s)} to inspect,
\texttt{ai\_session\_close(\$s)} to drop.

\section{\texorpdfstring{\texttt{ai\_session\_send}}{ai\_session\_send}}\label{ai_session_send}

\texttt{ai\_session\_send} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_session\_send $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_session\_send |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_session\_history}}{ai\_session\_history}}\label{ai_session_history}

\texttt{ai\_session\_history} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_session\_history $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_session\_history |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_session\_close}}{ai\_session\_close}}\label{ai_session_close}

\texttt{ai\_session\_close} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_session\_close $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_session\_close |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_session\_reset}}{ai\_session\_reset}}\label{ai_session_reset}

\texttt{ai\_session\_reset} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_session\_reset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_session\_reset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_memory\_save}}{ai\_memory\_save}}\label{ai_memory_save}

\texttt{ai\_memory\_save("id",\ "content",\ \$metadata?,\ \$path?)} ---
embed + persist a doc in the sqlite-backed memory store.

\section{\texorpdfstring{\texttt{ai\_memory\_recall}}{ai\_memory\_recall}}\label{ai_memory_recall}

\texttt{ai\_memory\_recall("query",\ top\_k\ =\textgreater{}\ 5)} ---
re-embed query, return top-k matches by cosine similarity. Each entry:
\texttt{+\{id,\ content,\ score,\ metadata\}}.

\section{\texorpdfstring{\texttt{ai\_memory\_forget}}{ai\_memory\_forget}}\label{ai_memory_forget}

\texttt{ai\_memory\_forget} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_memory\_forget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_memory\_forget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_memory\_count}}{ai\_memory\_count}}\label{ai_memory_count}

\texttt{ai\_memory\_count} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_memory\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_memory\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_memory\_clear}}{ai\_memory\_clear}}\label{ai_memory_clear}

\texttt{ai\_memory\_clear} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_memory\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_memory\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_vision}}{ai\_vision}}\label{ai_vision}

\texttt{ai\_vision} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_vision $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_vision |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_pdf}}{ai\_pdf}}\label{ai_pdf}

\texttt{ai\_pdf} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_budget}}{ai\_budget}}\label{ai_budget}

\texttt{ai\_budget(\$usd\_cap,\ sub\ \{\ ...\ \})} --- runs the block;
raises a runtime error if AI spend during the block exceeds
\texttt{\$usd\_cap}. Restores prior global cap on exit.

\section{\texorpdfstring{\texttt{ai\_last\_thinking}}{ai\_last\_thinking}}\label{ai_last_thinking}

\texttt{ai\_last\_thinking} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_last\_thinking $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_last\_thinking |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_batch}}{ai\_batch}}\label{ai_batch}

\texttt{ai\_batch} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_batch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_batch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_pmap}}{ai\_pmap}}\label{ai_pmap}

\texttt{ai\_pmap} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_pmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_pmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_cosine}}{vec\_cosine}}\label{vec_cosine}

\texttt{vec\_cosine\ \textbackslash{}@a,\ \textbackslash{}@b} --- cosine
similarity in \texttt{{[}-1,\ 1{]}}. Both args are arrayrefs of floats
(typical embedding shape).

\section{\texorpdfstring{\texttt{vec\_search}}{vec\_search}}\label{vec_search}

\texttt{vec\_search\ \textbackslash{}@query,\ \textbackslash{}@candidates,\ top\_k\ =\textgreater{}\ N}
--- return top-k matches as \texttt{+\{idx,\ score\}}.

\section{\texorpdfstring{\texttt{vec\_topk}}{vec\_topk}}\label{vec_topk}

\texttt{vec\_topk} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_topk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_topk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_search\_tool}}{web\_search\_tool}}\label{web_search_tool}

\texttt{web\_search\_tool()} --- built-in tool spec for
\texttt{tools\ =\textgreater{}\ {[}...{]}}. Brave Search via
\texttt{\$BRAVE\_SEARCH\_API\_KEY}, falls back to DuckDuckGo HTML
scrape.

\section{\texorpdfstring{\texttt{fetch\_url\_tool}}{fetch\_url\_tool}}\label{fetch_url_tool}

\texttt{fetch\_url\_tool()} --- built-in tool spec that fetches a URL
and returns text.

\section{\texorpdfstring{\texttt{read\_file\_tool}}{read\_file\_tool}}\label{read_file_tool}

\texttt{read\_file\_tool()} --- built-in tool spec that reads a file
from disk.

\section{\texorpdfstring{\texttt{run\_code\_tool}}{run\_code\_tool}}\label{run_code_tool}

\texttt{run\_code\_tool()} --- built-in tool spec that runs Python code
in a subprocess (10s timeout, returns stdout+stderr).

\section{\texorpdfstring{\texttt{tool}}{tool}}\label{tool}

\texttt{tool\ fn\ NAME(\$p1:\ type,\ \$p2:\ type)\ -\textgreater{}\ Type\ "docstring"\ \{\ body\ \}}
--- declare an agent-callable tool. Param types become the JSON Schema.
Auto-registers via \texttt{ai\_register\_tool} so bare
\texttt{ai(\$prompt)} calls see it.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{tool fn weather($city: string) "Get current weather" \{}
\NormalTok{    fetch "https://api.weather.com/" . uri\_encode($city)}
\NormalTok{\}}

\NormalTok{tool fn calc($a: int, $b: int) {-}\textgreater{} int "Add two ints" \{ $a + $b \}}

\NormalTok{my $r = ai("what\textquotesingle{}s the weather in SF and 7+5?");}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-mcp-model-context-protocol}
\chapter{MCP (Model Context Protocol)}\label{mcp-model-context-protocol}

13 topics

\section{\texorpdfstring{\texttt{mcp\_connect}}{mcp\_connect}}\label{mcp_connect}

\texttt{mcp\_connect\ "stdio:CMD\ ARGS"} or
\texttt{mcp\_connect\ "https://server/mcp"} --- connect to an MCP
server. Speaks JSON-RPC over stdio (subprocess) or streamable HTTP.
Returns a handle.

\section{\texorpdfstring{\texttt{mcp\_tools}}{mcp\_tools}}\label{mcp_tools}

\texttt{mcp\_tools\ \$h} --- list the server\textquotesingle s tools.
Cached after first call.

\section{\texorpdfstring{\texttt{mcp\_resources}}{mcp\_resources}}\label{mcp_resources}

\texttt{mcp\_resources} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_resources $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_resources |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_prompts}}{mcp\_prompts}}\label{mcp_prompts}

\texttt{mcp\_prompts} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_prompts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_prompts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_call}}{mcp\_call}}\label{mcp_call}

\texttt{mcp\_call\ \$h,\ "tool\_name",\ +\{...args\}} --- invoke a tool
on the connected server.

\section{\texorpdfstring{\texttt{mcp\_resource}}{mcp\_resource}}\label{mcp_resource}

\texttt{mcp\_resource} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_resource $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_resource |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_prompt}}{mcp\_prompt}}\label{mcp_prompt}

\texttt{mcp\_prompt} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_prompt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_prompt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_close}}{mcp\_close}}\label{mcp_close}

\texttt{mcp\_close} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_close $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_close |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_attach\_to\_ai}}{mcp\_attach\_to\_ai}}\label{mcp_attach_to_ai}

\texttt{mcp\_attach\_to\_ai\ \$h} --- register a connected MCP server so
subsequent bare \texttt{ai(\$prompt)} calls auto-include its tools.

\section{\texorpdfstring{\texttt{mcp\_detach\_from\_ai}}{mcp\_detach\_from\_ai}}\label{mcp_detach_from_ai}

\texttt{mcp\_detach\_from\_ai} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_detach\_from\_ai $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_detach\_from\_ai |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_attached}}{mcp\_attached}}\label{mcp_attached}

\texttt{mcp\_attached} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcp\_attached $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcp\_attached |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_server\_start}}{mcp\_server\_start}}\label{mcp_server_start}

\texttt{mcp\_server\_start\ "name",\ +\{\ tools\ =\textgreater{}\ {[}...{]}\ \}}
--- run a stdio JSON-RPC MCP server in-process. Pair with
\texttt{s\_web\ build} to ship a self-contained MCP server binary.

For parser-level sugar, use
\texttt{mcp\_server\ "name"\ \{\ tool\ foo(\$a)\ "..."\ \{...\}\ \}}.

\section{\texorpdfstring{\texttt{mcp\_server}}{mcp\_server}}\label{mcp_server}

\texttt{mcp\_server\ "name"\ \{\ tool\ NAME(args)\ "doc"\ \{\ body\ \}\ ...\ \}}
--- declarative MCP server block. Compiles to
\texttt{mcp\_server\_start("name",\ +\{\ tools\ =\textgreater{}\ {[}...{]}\ \})}
with private helper fns for each tool body.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{mcp\_server "filesystem" \{}
\NormalTok{    tool read\_file($path: string) "Read file contents" \{ slurp $path \}}
\NormalTok{    tool list\_dir($path: string)  "List dir entries"  \{ join("\textbackslash{}n", readdir $path) \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-web-framework-stryke-web-readme-md}
\chapter{Web framework
(stryke\_web/README.md)}\label{web-framework-stryke_webreadme.md}

112 topics

\section{\texorpdfstring{\texttt{web\_route}}{web\_route}}\label{web_route}

\texttt{web\_route\ "VERB\ /path",\ "controller\#action"} --- register a
route in the global router.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{web\_route "GET /posts", "posts\#index"}
\NormalTok{web\_route "POST /posts", "posts\#create"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_resources}}{web\_resources}}\label{web_resources}

\texttt{web\_resources\ "posts"} --- register the 7-route REST scaffold
(index/show/new/create/edit/update/destroy) for a resource.

\section{\texorpdfstring{\texttt{web\_root}}{web\_root}}\label{web_root}

\texttt{web\_root\ "posts\#index"} --- shortcut for
\texttt{web\_route\ "GET\ /"}.

\section{\texorpdfstring{\texttt{web\_application\_config}}{web\_application\_config}}\label{web_application_config}

\texttt{web\_application\_config} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_application\_config $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_application\_config |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_render}}{web\_render}}\label{web_render}

\texttt{web\_render\ html\ =\textgreater{}\ "..."} /
\texttt{text\ =\textgreater{}\ ...} /
\texttt{json\ =\textgreater{}\ ...} /
\texttt{template\ =\textgreater{}\ "posts/index",\ locals\ =\textgreater{}\ +\{...\}}
--- emit a response. Templates resolve \texttt{app/views/...html.erb},
run through the ERB engine, wrap in the application layout.

\section{\texorpdfstring{\texttt{web\_render\_partial}}{web\_render\_partial}}\label{web_render_partial}

\texttt{web\_render\_partial} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_render\_partial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_render\_partial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_redirect}}{web\_redirect}}\label{web_redirect}

\texttt{web\_redirect\ "/path",\ 302} --- issue a 3xx redirect with
\texttt{Location} header.

\section{\texorpdfstring{\texttt{web\_json}}{web\_json}}\label{web_json}

\texttt{web\_json} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_json $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_json |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_text}}{web\_text}}\label{web_text}

\texttt{web\_text} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_params}}{web\_params}}\label{web_params}

\texttt{web\_params()} --- hashref of query + form-urlencoded body +
JSON body + path captures.

\section{\texorpdfstring{\texttt{web\_request}}{web\_request}}\label{web_request}

\texttt{web\_request} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_request $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_request |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_routes\_table}}{web\_routes\_table}}\label{web_routes_table}

\texttt{web\_routes\_table} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_routes\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_routes\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_boot\_application}}{web\_boot\_application}}\label{web_boot_application}

\texttt{web\_boot\_application} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_boot\_application $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_boot\_application |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_db\_connect}}{web\_db\_connect}}\label{web_db_connect}

\texttt{web\_db\_connect\ "sqlite://path"} --- open and cache the global
SQLite connection. Required before any \texttt{web\_model\_*} call.

\section{\texorpdfstring{\texttt{web\_db\_execute}}{web\_db\_execute}}\label{web_db_execute}

\texttt{web\_db\_execute} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_db\_execute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_db\_execute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_db\_query}}{web\_db\_query}}\label{web_db_query}

\texttt{web\_db\_query} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_db\_query $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_db\_query |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_jobs\_init}}{web\_jobs\_init}}\label{web_jobs_init}

\texttt{web\_jobs\_init()} --- create the SQLite \texttt{jobs} table if
it doesn\textquotesingle t exist. Idempotent.

\section{\texorpdfstring{\texttt{web\_job\_enqueue}}{web\_job\_enqueue}}\label{web_job_enqueue}

\texttt{web\_job\_enqueue("name",\ +\{...args\},\ queue\ =\textgreater{}\ "...",\ priority\ =\textgreater{}\ N,\ max\_attempts\ =\textgreater{}\ N)}
→ job id (i64). Status starts as \texttt{pending}.

\section{\texorpdfstring{\texttt{web\_job\_dequeue}}{web\_job\_dequeue}}\label{web_job_dequeue}

\texttt{web\_job\_dequeue(queue\ =\textgreater{}\ "...")} →
\texttt{+\{id,\ name,\ args\_json,\ args,\ attempts,\ max\_attempts\}}
or undef. Atomically marks the picked job as \texttt{running} and
increments \texttt{attempts}.

\section{\texorpdfstring{\texttt{web\_job\_complete}}{web\_job\_complete}}\label{web_job_complete}

\texttt{web\_job\_complete(\$id)} --- mark a running job as
\texttt{done}.

\section{\texorpdfstring{\texttt{web\_job\_fail}}{web\_job\_fail}}\label{web_job_fail}

\texttt{web\_job\_fail(\$id,\ error\ =\textgreater{}\ "msg")} --- if
\texttt{attempts\ \textless{}\ max\_attempts}, returns to
\texttt{pending} for retry; otherwise marked \texttt{failed}. Returns
the new status.

\section{\texorpdfstring{\texttt{web\_jobs\_list}}{web\_jobs\_list}}\label{web_jobs_list}

\texttt{web\_jobs\_list(queue\ =\textgreater{}\ "...",\ status\ =\textgreater{}\ "...",\ limit\ =\textgreater{}\ 50)}
→ arrayref of job hashrefs.

\section{\texorpdfstring{\texttt{web\_jobs\_stats}}{web\_jobs\_stats}}\label{web_jobs_stats}

\texttt{web\_jobs\_stats()} →
\texttt{+\{pending,\ running,\ done,\ failed\}}.

\section{\texorpdfstring{\texttt{web\_job\_purge}}{web\_job\_purge}}\label{web_job_purge}

\texttt{web\_job\_purge(status\ =\textgreater{}\ "done")} → number of
rows deleted.

\section{\texorpdfstring{\texttt{web\_db\_begin}}{web\_db\_begin}}\label{web_db_begin}

\texttt{web\_db\_begin} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_db\_begin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_db\_begin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_db\_commit}}{web\_db\_commit}}\label{web_db_commit}

\texttt{web\_db\_commit} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_db\_commit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_db\_commit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_db\_rollback}}{web\_db\_rollback}}\label{web_db_rollback}

\texttt{web\_db\_rollback} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_db\_rollback $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_db\_rollback |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_all}}{web\_model\_all}}\label{web_model_all}

\texttt{web\_model\_all\ "posts"} ---
\texttt{SELECT\ *\ FROM\ posts\ ORDER\ BY\ id}. Returns arrayref of
hashrefs.

\section{\texorpdfstring{\texttt{web\_model\_find}}{web\_model\_find}}\label{web_model_find}

\texttt{web\_model\_find\ "posts",\ \$id} --- find by id; returns
hashref or undef.

\section{\texorpdfstring{\texttt{web\_model\_where}}{web\_model\_where}}\label{web_model_where}

\texttt{web\_model\_where} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_where $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_where |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_create}}{web\_model\_create}}\label{web_model_create}

\texttt{web\_model\_create\ "posts",\ +\{title\ =\textgreater{}\ "...",\ body\ =\textgreater{}\ "..."\}}
--- INSERT + return new row with id and auto-set
\texttt{created\_at}/\texttt{updated\_at}.

\section{\texorpdfstring{\texttt{web\_model\_update}}{web\_model\_update}}\label{web_model_update}

\texttt{web\_model\_update} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_destroy}}{web\_model\_destroy}}\label{web_model_destroy}

\texttt{web\_model\_destroy} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_destroy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_destroy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_soft\_destroy}}{web\_model\_soft\_destroy}}\label{web_model_soft_destroy}

\texttt{web\_model\_soft\_destroy} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_soft\_destroy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_soft\_destroy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_paginate}}{web\_model\_paginate}}\label{web_model_paginate}

\texttt{web\_model\_paginate} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_paginate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_paginate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_search}}{web\_model\_search}}\label{web_model_search}

\texttt{web\_model\_search} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_count}}{web\_model\_count}}\label{web_model_count}

\texttt{web\_model\_count} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_first}}{web\_model\_first}}\label{web_model_first}

\texttt{web\_model\_first} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_last}}{web\_model\_last}}\label{web_model_last}

\texttt{web\_model\_last} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_increment}}{web\_model\_increment}}\label{web_model_increment}

\texttt{web\_model\_increment} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_increment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_increment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_model\_with}}{web\_model\_with}}\label{web_model_with}

\texttt{web\_model\_with} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_model\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_model\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_create\_table}}{web\_create\_table}}\label{web_create_table}

\texttt{web\_create\_table} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_create\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_create\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_drop\_table}}{web\_drop\_table}}\label{web_drop_table}

\texttt{web\_drop\_table} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_drop\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_drop\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_add\_column}}{web\_add\_column}}\label{web_add_column}

\texttt{web\_add\_column} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_add\_column $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_add\_column |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_remove\_column}}{web\_remove\_column}}\label{web_remove_column}

\texttt{web\_remove\_column} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_remove\_column $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_remove\_column |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_migrate}}{web\_migrate}}\label{web_migrate}

\texttt{web\_migrate()} --- apply every \texttt{up} block from
\texttt{db/migrate/*.stk} whose version isn\textquotesingle t yet in
\texttt{schema\_migrations}.

\section{\texorpdfstring{\texttt{web\_rollback}}{web\_rollback}}\label{web_rollback}

\texttt{web\_rollback} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_rollback $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_rollback |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_validate}}{web\_validate}}\label{web_validate}

\texttt{web\_validate\ \$attrs,\ +\{title\ =\textgreater{}\ "presence,length:1..100",\ email\ =\textgreater{}\ "format:\^{}.+@.+\$"\}}
--- returns \texttt{+\{ok\ =\textgreater{}\ 1\}} or
\texttt{+\{ok\ =\textgreater{}\ 0,\ errors\ =\textgreater{}\ +\{...\}\}}.
Validators: \texttt{presence}, \texttt{length:MIN..MAX},
\texttt{format:REGEX}, \texttt{numericality},
\texttt{inclusion:a\textbar{}b\textbar{}c},
\texttt{confirmation:other\_field}.

\section{\texorpdfstring{\texttt{web\_permit}}{web\_permit}}\label{web_permit}

\texttt{web\_permit} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_permit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_permit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_password\_hash}}{web\_password\_hash}}\label{web_password_hash}

\texttt{web\_password\_hash\ \$pw} returns a
\texttt{web1\$saltHex\$digest} shaped string.
\texttt{web\_password\_verify\ \$pw,\ \$stored} returns 1/0. SHA-256 +
16-byte salt; constant-time compare.

\section{\texorpdfstring{\texttt{web\_session}}{web\_session}}\label{web_session}

\texttt{web\_session} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_session $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_session |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_session\_set}}{web\_session\_set}}\label{web_session_set}

Server-side session storage backed by a signed cookie.
\texttt{web\_session\_set("user\_id",\ 42)} /
\texttt{web\_session\_get("user\_id")}. Cookie value is base64-JSON;
HttpOnly + SameSite=Lax by default.

\section{\texorpdfstring{\texttt{web\_session\_clear}}{web\_session\_clear}}\label{web_session_clear}

\texttt{web\_session\_clear} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_session\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_session\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_set\_cookie}}{web\_set\_cookie}}\label{web_set_cookie}

\texttt{web\_set\_cookie} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_set\_cookie $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_set\_cookie |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_cookies}}{web\_cookies}}\label{web_cookies}

\texttt{web\_cookies} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_cookies $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_cookies |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_flash}}{web\_flash}}\label{web_flash}

\texttt{web\_flash} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_flash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_flash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_flash\_set}}{web\_flash\_set}}\label{web_flash_set}

\texttt{web\_flash\_set} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_flash\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_flash\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_flash\_get}}{web\_flash\_get}}\label{web_flash_get}

\texttt{web\_flash\_get} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_flash\_get $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_flash\_get |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_jwt\_encode}}{web\_jwt\_encode}}\label{web_jwt_encode}

\texttt{web\_jwt\_encode\ +\{user\_id\ =\textgreater{}\ 1,\ role\ =\textgreater{}\ "admin"\}}
--- HS256-sign a JWT using \texttt{secret\_key\_base} from
\texttt{web\_application\_config}.

\section{\texorpdfstring{\texttt{web\_jwt\_decode}}{web\_jwt\_decode}}\label{web_jwt_decode}

\texttt{web\_jwt\_decode\ \$token} --- verify + decode an HS256 JWT.
Returns the payload hashref or undef on bad signature.

\section{\texorpdfstring{\texttt{web\_bearer\_token}}{web\_bearer\_token}}\label{web_bearer_token}

\texttt{web\_bearer\_token} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_bearer\_token $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_bearer\_token |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_otp\_secret}}{web\_otp\_secret}}\label{web_otp_secret}

TOTP / 2FA --- RFC 6238, 30-second window, ±1 step skew tolerance.
\texttt{web\_otp\_secret()} returns a base32 secret to share with the
authenticator app; \texttt{web\_otp\_generate(\$secret)} returns the
current 6-digit code; \texttt{web\_otp\_verify(\$secret,\ \$code)}
returns 1/0.

\section{\texorpdfstring{\texttt{web\_token\_for}}{web\_token\_for}}\label{web_token_for}

\texttt{web\_token\_for} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_token\_for $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_token\_for |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_token\_consume}}{web\_token\_consume}}\label{web_token_consume}

\texttt{web\_token\_consume} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_token\_consume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_token\_consume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_can}}{web\_can}}\label{web_can}

\texttt{web\_can} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_can $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_can |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_signed}}{web\_signed}}\label{web_signed}

\texttt{web\_signed} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_signed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_signed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_unsigned}}{web\_unsigned}}\label{web_unsigned}

\texttt{web\_unsigned} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_unsigned $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_unsigned |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_cache\_get}}{web\_cache\_get}}\label{web_cache_get}

\texttt{web\_cache\_get} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_cache\_get $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_cache\_get |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_cache\_set}}{web\_cache\_set}}\label{web_cache_set}

\texttt{web\_cache\_set} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_cache\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_cache\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_cache\_delete}}{web\_cache\_delete}}\label{web_cache_delete}

\texttt{web\_cache\_delete} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_cache\_delete $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_cache\_delete |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_cache\_clear}}{web\_cache\_clear}}\label{web_cache_clear}

\texttt{web\_cache\_clear} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_cache\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_cache\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_t}}{web\_t}}\label{web_t}

\texttt{web\_t} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_load\_locale}}{web\_load\_locale}}\label{web_load_locale}

\texttt{web\_load\_locale} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_load\_locale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_load\_locale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_log}}{web\_log}}\label{web_log}

\texttt{web\_log} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_log $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_log |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_set\_header}}{web\_set\_header}}\label{web_set_header}

\texttt{web\_set\_header} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_set\_header $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_set\_header |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_status}}{web\_status}}\label{web_status}

\texttt{web\_status} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_status $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_status |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_uuid}}{web\_uuid}}\label{web_uuid}

\texttt{web\_uuid} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_uuid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_uuid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_now}}{web\_now}}\label{web_now}

\texttt{web\_now} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_now $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_now |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_security\_headers}}{web\_security\_headers}}\label{web_security_headers}

\texttt{web\_security\_headers} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_security\_headers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_security\_headers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_openapi}}{web\_openapi}}\label{web_openapi}

\texttt{web\_openapi} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_openapi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_openapi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_etag}}{web\_etag}}\label{web_etag}

\texttt{web\_etag} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_etag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_etag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_csv}}{web\_csv}}\label{web_csv}

\texttt{web\_csv} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_csv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_csv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_markdown}}{web\_markdown}}\label{web_markdown}

\texttt{web\_markdown} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_markdown $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_markdown |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_md}}{web\_md}}\label{web_md}

\texttt{web\_md} --- web framework (docs/web\_framework.md) builtin.
Alias for \texttt{web\_markdown}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_md $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_md |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_content\_for}}{web\_content\_for}}\label{web_content_for}

\texttt{web\_content\_for} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_content\_for $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_content\_for |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_yield\_content}}{web\_yield\_content}}\label{web_yield_content}

\texttt{web\_yield\_content} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_yield\_content $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_yield\_content |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_jsonapi\_resource}}{web\_jsonapi\_resource}}\label{web_jsonapi_resource}

\texttt{web\_jsonapi\_resource} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_jsonapi\_resource $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_jsonapi\_resource |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_jsonapi\_collection}}{web\_jsonapi\_collection}}\label{web_jsonapi_collection}

\texttt{web\_jsonapi\_collection} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_jsonapi\_collection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_jsonapi\_collection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_jsonapi\_error}}{web\_jsonapi\_error}}\label{web_jsonapi_error}

\texttt{web\_jsonapi\_error} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_jsonapi\_error $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_jsonapi\_error |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_rate\_limit}}{web\_rate\_limit}}\label{web_rate_limit}

\texttt{web\_rate\_limit} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_rate\_limit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_rate\_limit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_before\_action}}{web\_before\_action}}\label{web_before_action}

\texttt{web\_before\_action} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_before\_action $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_before\_action |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_after\_action}}{web\_after\_action}}\label{web_after_action}

\texttt{web\_after\_action} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_after\_action $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_after\_action |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_h}}{web\_h}}\label{web_h}

\texttt{web\_h} --- web framework (docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_link\_to}}{web\_link\_to}}\label{web_link_to}

\texttt{web\_link\_to} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_link\_to $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_link\_to |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_button\_to}}{web\_button\_to}}\label{web_button_to}

\texttt{web\_button\_to} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_button\_to $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_button\_to |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_form\_with}}{web\_form\_with}}\label{web_form_with}

\texttt{web\_form\_with} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_form\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_form\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_form\_close}}{web\_form\_close}}\label{web_form_close}

\texttt{web\_form\_close} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_form\_close $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_form\_close |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_text\_field}}{web\_text\_field}}\label{web_text_field}

\texttt{web\_text\_field} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_text\_field $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_text\_field |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_text\_area}}{web\_text\_area}}\label{web_text_area}

\texttt{web\_text\_area} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_text\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_text\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_check\_box}}{web\_check\_box}}\label{web_check_box}

\texttt{web\_check\_box} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_check\_box $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_check\_box |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_csrf\_meta\_tag}}{web\_csrf\_meta\_tag}}\label{web_csrf_meta_tag}

\texttt{web\_csrf\_meta\_tag} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_csrf\_meta\_tag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_csrf\_meta\_tag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_stylesheet\_link\_tag}}{web\_stylesheet\_link\_tag}}\label{web_stylesheet_link_tag}

\texttt{web\_stylesheet\_link\_tag} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_stylesheet\_link\_tag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_stylesheet\_link\_tag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_javascript\_link\_tag}}{web\_javascript\_link\_tag}}\label{web_javascript_link_tag}

\texttt{web\_javascript\_link\_tag} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_javascript\_link\_tag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_javascript\_link\_tag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_image\_tag}}{web\_image\_tag}}\label{web_image_tag}

\texttt{web\_image\_tag} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_image\_tag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_image\_tag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_truncate}}{web\_truncate}}\label{web_truncate}

\texttt{web\_truncate} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_truncate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_truncate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_pluralize}}{web\_pluralize}}\label{web_pluralize}

\texttt{web\_pluralize} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_pluralize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_pluralize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_time\_ago\_in\_words}}{web\_time\_ago\_in\_words}}\label{web_time_ago_in_words}

\texttt{web\_time\_ago\_in\_words} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_time\_ago\_in\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_time\_ago\_in\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_faker\_name}}{web\_faker\_name}}\label{web_faker_name}

\texttt{web\_faker\_name} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_faker\_name $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_faker\_name |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_faker\_email}}{web\_faker\_email}}\label{web_faker_email}

\texttt{web\_faker\_email} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_faker\_email $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_faker\_email |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_faker\_sentence}}{web\_faker\_sentence}}\label{web_faker_sentence}

\texttt{web\_faker\_sentence} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_faker\_sentence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_faker\_sentence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_faker\_paragraph}}{web\_faker\_paragraph}}\label{web_faker_paragraph}

\texttt{web\_faker\_paragraph} --- web framework
(docs/web\_framework.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_faker\_paragraph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_faker\_paragraph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{web\_faker\_int}}{web\_faker\_int}}\label{web_faker_int}

\texttt{web\_faker\_int} --- web framework (docs/web\_framework.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = web\_faker\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map web\_faker\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\protect\phantomsection\label{ch-stress-telemetry-docs-stress-testing-md}
\chapter{Stress / telemetry
(docs/STRESS\_TESTING.md)}\label{stress-telemetry-docsstress_testing.md}

42 topics

\section{\texorpdfstring{\texttt{stress\_fp}}{stress\_fp}}\label{stress_fp}

\texttt{stress\_fp\ \$secs} --- float matrix-multiply pinning every
core. Returns total FLOP count.

\section{\texorpdfstring{\texttt{stress\_int}}{stress\_int}}\label{stress_int}

\texttt{stress\_int\ \$secs} --- integer pipeline pinning every core.

\section{\texorpdfstring{\texttt{stress\_cache}}{stress\_cache}}\label{stress_cache}

\texttt{stress\_cache\ \$secs,\ \$kb} --- pound a working set of
\texttt{kb} KiB per core in random order. Default 1024
(\textasciitilde{} L2/L3 boundary).

\section{\texorpdfstring{\texttt{stress\_branch}}{stress\_branch}}\label{stress_branch}

\texttt{stress\_branch} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_branch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_branch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_sort}}{stress\_sort}}\label{stress_sort}

\texttt{stress\_sort} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_sort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_sort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_alloc}}{stress\_alloc}}\label{stress_alloc}

\texttt{stress\_alloc} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_alloc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_alloc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_mmap}}{stress\_mmap}}\label{stress_mmap}

\texttt{stress\_mmap} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_mmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_mmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_disk}}{stress\_disk}}\label{stress_disk}

\texttt{stress\_disk\ \$path,\ \$secs,\ \$mb\_per\_write} --- sustained
sequential write + fsync + read across all cores.

\section{\texorpdfstring{\texttt{stress\_iops}}{stress\_iops}}\label{stress_iops}

\texttt{stress\_iops\ \$path,\ \$secs,\ \$block\_kb} --- small random
reads/writes for IOPS testing. Default 4KB blocks.

\section{\texorpdfstring{\texttt{stress\_net}}{stress\_net}}\label{stress_net}

\texttt{stress\_net\ "host:port",\ \$secs,\ \$conns} --- open
\texttt{conns} TCP connections per core, pump bytes.

\section{\texorpdfstring{\texttt{stress\_http}}{stress\_http}}\label{stress_http}

\texttt{stress\_http\ \$url,\ \$secs,\ \$conns} --- HTTP GET storm.
Counts 2xx responses.

\section{\texorpdfstring{\texttt{stress\_dns}}{stress\_dns}}\label{stress_dns}

\texttt{stress\_dns} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_dns $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_dns |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_thread}}{stress\_thread}}\label{stress_thread}

\texttt{stress\_thread} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_thread $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_thread |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_fork}}{stress\_fork}}\label{stress_fork}

\texttt{stress\_fork} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_fork $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_fork |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_aes}}{stress\_aes}}\label{stress_aes}

\texttt{stress\_aes\ \$secs} --- AES-128 encrypt round-trip across
cores.

\section{\texorpdfstring{\texttt{stress\_compress}}{stress\_compress}}\label{stress_compress}

\texttt{stress\_compress\ \$secs,\ \$kb} --- gzip compress+decompress
payload of \texttt{kb} KiB per core.

\section{\texorpdfstring{\texttt{stress\_regex}}{stress\_regex}}\label{stress_regex}

\texttt{stress\_regex} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_regex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_regex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_json}}{stress\_json}}\label{stress_json}

\texttt{stress\_json} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_json $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_json |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_burst}}{stress\_burst}}\label{stress_burst}

\texttt{stress\_burst} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_burst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_burst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_ramp}}{stress\_ramp}}\label{stress_ramp}

\texttt{stress\_ramp} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_ramp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_ramp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_oscillate}}{stress\_oscillate}}\label{stress_oscillate}

\texttt{stress\_oscillate} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_oscillate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_oscillate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_all}}{stress\_all}}\label{stress_all}

\texttt{stress\_all\ \$secs} --- run every stress kernel above in
parallel for \texttt{secs}. Returns a hashref of per-kernel counts.

\section{\texorpdfstring{\texttt{stress\_cores}}{stress\_cores}}\label{stress_cores}

\texttt{stress\_cores} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_cores $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_cores |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_temp}}{stress\_temp}}\label{stress_temp}

Telemetry helpers: \texttt{stress\_temp()} reads CPU temp from
\texttt{/sys/class/thermal} (Linux), \texttt{stress\_freq()} averages
cpufreq across cores, \texttt{stress\_throttled()} returns 1 when freq
\textless{} 80\% of max AND temp \textgreater{} 80°C,
\texttt{stress\_load()} returns \texttt{+\{m1,\ m5,\ m15\}},
\texttt{stress\_meminfo()} returns total/used/free/swap bytes.

\section{\texorpdfstring{\texttt{stress\_thermal\_zones}}{stress\_thermal\_zones}}\label{stress_thermal_zones}

\texttt{stress\_thermal\_zones} --- stress / telemetry extensions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_thermal\_zones $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_thermal\_zones |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_arm\_kill\_switch}}{stress\_arm\_kill\_switch}}\label{stress_arm_kill_switch}

\texttt{stress\_arm\_kill\_switch} --- stress / telemetry extensions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_arm\_kill\_switch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_arm\_kill\_switch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_killed}}{stress\_killed}}\label{stress_killed}

\texttt{stress\_killed} --- stress / telemetry extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_killed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_killed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_disarm\_kill\_switch}}{stress\_disarm\_kill\_switch}}\label{stress_disarm_kill_switch}

\texttt{stress\_disarm\_kill\_switch} --- stress / telemetry extensions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stress\_disarm\_kill\_switch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stress\_disarm\_kill\_switch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stress\_metrics\_record}}{stress\_metrics\_record}}\label{stress_metrics_record}

\texttt{stress\_metrics\_record("name",\ \$value,\ k1\ =\textgreater{}\ v1,\ ...)}
--- append a sample to the metrics history. Labels are stringified.

\section{\texorpdfstring{\texttt{stress\_metrics\_clear}}{stress\_metrics\_clear}}\label{stress_metrics_clear}

\texttt{stress\_metrics\_clear()} --- wipe the metrics history. Pair
with \texttt{stress\_metrics\_count()} before/after to verify.

\section{\texorpdfstring{\texttt{stress\_metrics\_count}}{stress\_metrics\_count}}\label{stress_metrics_count}

\texttt{stress\_metrics\_count()} → current number of samples in the
history.

\section{\texorpdfstring{\texttt{stress\_metrics\_export}}{stress\_metrics\_export}}\label{stress_metrics_export}

\texttt{stress\_metrics\_export("path",\ format\ =\textgreater{}\ "csv"\textbar{}"json"\textbar{}"prom")}
→ number of samples written.

\section{\texorpdfstring{\texttt{stress\_metrics\_prometheus}}{stress\_metrics\_prometheus}}\label{stress_metrics_prometheus}

\texttt{stress\_metrics\_prometheus()} → string in Prometheus text
exposition format. Latest value per (name, labels) wins. Drop into a
\texttt{/metrics} HTTP handler.

\section{\texorpdfstring{\texttt{stress\_metrics\_json}}{stress\_metrics\_json}}\label{stress_metrics_json}

\texttt{stress\_metrics\_json()} → JSON string of the entire metrics
history.

\section{\texorpdfstring{\texttt{stress\_metrics\_csv}}{stress\_metrics\_csv}}\label{stress_metrics_csv}

\texttt{stress\_metrics\_csv()} → CSV string with
\texttt{ts\_ms,name,value,labels} columns.

\section{\texorpdfstring{\texttt{stress\_metrics\_watch}}{stress\_metrics\_watch}}\label{stress_metrics_watch}

\texttt{stress\_metrics\_watch(field\ =\textgreater{}\ "stress\_temp",\ interval\_ms\ =\textgreater{}\ 1000,\ max\_ticks\ =\textgreater{}\ 60)}
→ arrayref of values sampled at the requested cadence. Polls the metrics
history for new entries matching \texttt{field}.

\section{\texorpdfstring{\texttt{audit\_log}}{audit\_log}}\label{audit_log}

\texttt{audit\_log("event\_name",\ k1\ =\textgreater{}\ v1,\ ...)} ---
append one JSONL line to \texttt{\textasciitilde{}/.stryke/audit.log}
(or \texttt{\$STRYKE\_AUDIT\_LOG}). Never throws; returns 1/0.

\section{\texorpdfstring{\texttt{audit\_log\_path}}{audit\_log\_path}}\label{audit_log_path}

\texttt{audit\_log\_path()} → absolute path the next \texttt{audit\_log}
call will write to.

\section{\texorpdfstring{\texttt{secrets\_encrypt}}{secrets\_encrypt}}\label{secrets_encrypt}

\texttt{secrets\_encrypt(\$plain,\ key\ =\textgreater{}\ \$key)} →
base64 envelope (nonce(12) \textbar\textbar{} ciphertext
\textbar\textbar{} tag(16)). AES-256-GCM. Key must be 32 raw bytes or
32-byte base64.

\section{\texorpdfstring{\texttt{secrets\_decrypt}}{secrets\_decrypt}}\label{secrets_decrypt}

\texttt{secrets\_decrypt(\$envelope,\ key\ =\textgreater{}\ \$key)} →
plaintext, or undef on auth failure.

\section{\texorpdfstring{\texttt{secrets\_random\_key}}{secrets\_random\_key}}\label{secrets_random_key}

\texttt{secrets\_random\_key()} → fresh 32-byte AES-256 key as base64.
Reads \texttt{/dev/urandom} on Unix.

\section{\texorpdfstring{\texttt{secrets\_kdf}}{secrets\_kdf}}\label{secrets_kdf}

\texttt{secrets\_kdf(\$password,\ salt\ =\textgreater{}\ "...",\ iterations\ =\textgreater{}\ 600\_000)}
→ 32-byte key as base64. PBKDF2-HMAC-SHA256.

\protect\phantomsection\label{ch-pty-expect-docs-expect-feature-idea-md}
\chapter{PTY / expect
(docs/expect-feature-idea.md)}\label{pty-expect-docsexpect-feature-idea.md}

13 topics

\section{\texorpdfstring{\texttt{pty\_spawn}}{pty\_spawn}}\label{pty_spawn}

\texttt{pty\_spawn\ "cmd\ args"} or
\texttt{pty\_spawn("cmd",\ "arg1",\ "arg2")} --- allocate a PTY,
fork+exec the child, return a handle. Master fd is non-blocking.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $h = pty\_spawn("ssh user@host");}
\NormalTok{pty\_expect($h, qr/password:/, 30);}
\NormalTok{pty\_send($h, "hunter2\textbackslash{}n");}
\NormalTok{pty\_close($h);}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pty\_send}}{pty\_send}}\label{pty_send}

\texttt{pty\_send\ \$h,\ "text"} --- write to the PTY master. Handles
EAGAIN/EINTR; returns bytes written.

\section{\texorpdfstring{\texttt{pty\_read}}{pty\_read}}\label{pty_read}

\texttt{pty\_read} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pty\_read $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pty\_read |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pty\_expect}}{pty\_expect}}\label{pty_expect}

\texttt{pty\_expect\ \$h,\ qr/regex/,\ \$timeout\_secs} --- loop reading
until the regex matches the accumulated buffer or \texttt{timeout\_secs}
elapses. Returns the matched substring or undef on timeout/EOF. Buffer
is consumed up to (and including) the match.

\section{\texorpdfstring{\texttt{pty\_expect\_table}}{pty\_expect\_table}}\label{pty_expect_table}

\texttt{pty\_expect\_table\ \$h,\ {[}+\{re\ =\textgreater{}\ qr/.../,\ do\ =\textgreater{}\ sub\ \{...\}\},\ ...{]},\ \$timeout}
--- multi-pattern dispatch (Tcl \texttt{expect\ \{\ ...\ \}} block).
First match wins; the matched branch\textquotesingle s \texttt{do} sub
is called.

\section{\texorpdfstring{\texttt{pty\_buffer}}{pty\_buffer}}\label{pty_buffer}

\texttt{pty\_buffer} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pty\_buffer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pty\_buffer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pty\_alive}}{pty\_alive}}\label{pty_alive}

\texttt{pty\_alive} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pty\_alive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pty\_alive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pty\_eof}}{pty\_eof}}\label{pty_eof}

\texttt{pty\_eof} --- mcp (model context protocol) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pty\_eof $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pty\_eof |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pty\_close}}{pty\_close}}\label{pty_close}

\texttt{pty\_close\ \$h} --- SIGTERM → 200ms grace → SIGKILL. Returns
exit status.

\section{\texorpdfstring{\texttt{pty\_interact}}{pty\_interact}}\label{pty_interact}

\texttt{pty\_interact\ \$h} --- raw-mode handoff: forwards stdin →
master and master → stdout until EOF or Ctrl-{]}. Saves and restores tty
state.

\section{\texorpdfstring{\texttt{pty\_strip\_ansi}}{pty\_strip\_ansi}}\label{pty_strip_ansi}

\texttt{pty\_strip\_ansi\ \$text} → string with CSI/OSC/ESC sequences
removed. Useful before regex-matching against PTY output that mixes
color codes into prompts.

\section{\texorpdfstring{\texttt{pty\_after\_eof}}{pty\_after\_eof}}\label{pty_after_eof}

\texttt{pty\_after\_eof\ \$h,\ "callback\_name"} --- register an EOF
callback. Spawns a watcher thread that flips a fired flag once the PTY
closes. Pair with \texttt{pty\_pending\_events()} in your main loop.

\section{\texorpdfstring{\texttt{pty\_pending\_events}}{pty\_pending\_events}}\label{pty_pending_events}

\texttt{pty\_pending\_events()} → arrayref of
\texttt{+\{handle\_id,\ callback\}} for any \texttt{pty\_after\_eof}
registrations that have fired since the last call. Drains the fired
list.

\protect\phantomsection\label{ch-other}
\chapter{Other}\label{other}

6716 topics

\section{\texorpdfstring{\texttt{\%pc}}{\%pc}}\label{pc}

\texttt{parsec} (alias \texttt{pc}) --- pc ≈ 3.086×10¹⁶ m ≈ 3.26 ly.
Common astronomical distance unit.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pc        \# 3.0856775814913673e16 m}
\NormalTok{p pc / ly   \# \textasciitilde{}3.26 light years}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::aliases}}{\%stryke::aliases}}\label{strykealiases}

\texttt{\%stryke::aliases} (short: \texttt{\%a}) --- alias spelling →
canonical primary.

Keys are the 2nd-and-later names in each \texttt{try\_builtin} match
arm. For O(1) *reverse* lookup (primary → all its aliases), use
\texttt{\%stryke::primaries} / \texttt{\%p}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $a\{tj\}                                  \# "to\_json"}
\NormalTok{p $a\{bn\}                                  \# "basename"}
\NormalTok{p scalar keys \%a                          \# total alias count}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::all}}{\%stryke::all}}\label{strykeall}

\texttt{\%stryke::all} (short: \texttt{\%all}) --- every callable
*spelling* (primaries \textbf{and} aliases) → category. Aliases inherit
their primary\textquotesingle s category.

Use \texttt{\%all} when you want "how many names can I type?" or want to
look up an alias\textquotesingle s category without hopping through
\texttt{\%aliases}. Use \texttt{\%builtins} when you want unique
operations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p scalar keys \%all   \# total callable{-}spellings count}
\NormalTok{p $all\{tj\}           \# "serialization"  (alias resolves via inheritance)}
\NormalTok{p $all\{to\_json\}      \# "serialization"}
\NormalTok{keys \%all |\textgreater{} pager   \# browse every spelling}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::builtins}}{\%stryke::builtins}}\label{strykebuiltins}

\texttt{\%stryke::builtins} (short: \texttt{\%b}) --- every
\textbf{primary} callable name → its category. Primaries-only, so
\texttt{scalar\ keys\ \%b} is a clean unique-operation count. For the
"everything you can type" view (primaries + aliases), use
\texttt{\%stryke::all} / \texttt{\%all}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $b\{pmap\}               \# "parallel"}
\NormalTok{p $b\{to\_json\}            \# "serialization"}
\NormalTok{p scalar keys \%b         \# unique{-}op count}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::categories}}{\%stryke::categories}}\label{strykecategories}

\texttt{\%stryke::categories} (short: \texttt{\%c}) --- category string
→ arrayref of names in that category.

Inverted index on \texttt{\%builtins}. Gives O(1) reverse-lookup for
"list every op of kind X" queries that would otherwise be O(n)
\texttt{grep}s. Name lists are alphabetized.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{$c\{parallel\} |\textgreater{} e p                  \# every parallel op}
\NormalTok{p scalar @\{ $c\{parallel\} \}           \# how many?}
\NormalTok{p join ", ", @\{ $c\{"array / list"\} \} \# joined roster}
\NormalTok{keys \%c |\textgreater{} sort |\textgreater{} p                 \# all category names}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::descriptions}}{\%stryke::descriptions}}\label{strykedescriptions}

\texttt{\%stryke::descriptions} (short: \texttt{\%d}) --- name →
one-line summary.

First sentence of each LSP hover doc (\texttt{doc\_for\_label\_text}),
harvested at build time. Sparse --- only names that have a hover doc
appear, so \texttt{exists\ \$d\{\$name\}} doubles as "is this
documented?".

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $d\{pmap\}                                \# one{-}line summary}
\NormalTok{p $d\{to\_json\}                             \# "Serialize a PerlValue to a JSON string."}
\NormalTok{p scalar keys \%d                          \# count of documented ops}
\NormalTok{keys \%d |\textgreater{} grep \{ $d\{\_\} =\textasciitilde{} /parallel/i \} |\textgreater{} sort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::extensions}}{\%stryke::extensions}}\label{strykeextensions}

\texttt{\%stryke::extensions} (short: \texttt{\%e}) --- stryke-only
names, name → category.

Disjoint from \texttt{\%perl\_compats}. Everything \texttt{-\/-compat}
mode rejects at parse time, plus dispatch primaries like
\texttt{basename}/\texttt{ddump} that are extensions at runtime even
without a parser entry.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $e\{pmap\}                                \# "parallel"}
\NormalTok{keys \%e |\textgreater{} grep /\^{}p/ |\textgreater{} sort |\textgreater{} p         \# every p* parallel op}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::perl\_compats}}{\%stryke::perl\_compats}}\label{strykeperl_compats}

\texttt{\%stryke::perl\_compats} (short: \texttt{\%pc}) --- Perl 5 core
names only, name → category.

Subset of \texttt{\%builtins} restricted to names from
\texttt{is\_perl5\_core}. Direct O(1) access for the "show me just Perl
core" query.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $pc\{map\}                    \# "array / list"}
\NormalTok{p scalar keys \%pc             \# core{-}only count}
\NormalTok{keys \%pc |\textgreater{} sort |\textgreater{} p         \# enumerate every Perl core name}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{\%stryke::primaries}}{\%stryke::primaries}}\label{strykeprimaries}

\texttt{\%stryke::primaries} (short: \texttt{\%p}) --- primary
dispatcher name → arrayref of its aliases.

Inverted \texttt{\%aliases}. Primaries with no aliases still have an
entry (empty arrayref), so \texttt{exists\ \$p\{foo\}} reliably answers
"is foo a dispatch primary?" O(1).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{$p\{to\_json\} |\textgreater{} e p              \# ["tj"]}
\NormalTok{p scalar @\{ $p\{basename\} \}      \# how many aliases does basename have?}
\NormalTok{\# find every primary that has at least one alias:}
\NormalTok{keys \%p |\textgreater{} grep \{ scalar @\{$p\{\_\}\} \} |\textgreater{} sort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{CORE}}{CORE}}\label{core}

\texttt{CORE::} --- pseudo-namespace alias for every dispatch primary.
Every callable bare name is also reachable as \texttt{CORE::name}, with
identical semantics. The qualified spelling exists for tab-complete
affordance and explicit-namespace style; stryke rejects redefining a
builtin (\texttt{fn\ print\ \{\ ...\ \}} is a parse error), so there is
nothing to shadow at runtime.

The set is built dynamically: any name in
\texttt{keys\ \%stryke::builtins} is a valid \texttt{CORE::name}.
There\textquotesingle s no separate \texttt{\%CORE::} table ---
it\textquotesingle s a virtual namespace resolved at dispatch time.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{CORE::print "hello world\textbackslash{}n"                  \# ≡ print "hello world\textbackslash{}n"}
\NormalTok{my $r = CORE::sum(1, 2, 3)                   \# 6 — qualified call}
\NormalTok{map \{ CORE::sprintf("\%d", \_) \} @nums         \# any builtin}
\end{Highlighting}
\end{Shaded}

The \texttt{s\ docs\ CORE::name} form resolves to the bare-name page
(the alias and primary share docs). Aliases (\texttt{tj}, \texttt{bn},
\texttt{e}, \ldots) also support \texttt{CORE::tj} / \texttt{CORE::bn} /
\texttt{CORE::e}.

\section{\texorpdfstring{\texttt{CORE::pipe}}{CORE::pipe}}\label{corepipe}

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 \texttt{fork} so the
parent and child can exchange data.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{pipe(my $rd, my $wr) or die "pipe: $!"}
\NormalTok{if (fork() == 0) \{}
\NormalTok{    close($rd)}
\NormalTok{    print $wr "hello from child\textbackslash{}n"}
\NormalTok{    exit(0)}
\NormalTok{\}}
\NormalTok{close($wr)}
\NormalTok{my $msg = \textless{}$rd\textgreater{}}
\NormalTok{p $msg   \# hello from child}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a0}}{a0}}\label{a0}

\texttt{bohr\_radius} (alias \texttt{a0}) --- a₀ ≈ 5.29×10⁻¹¹ m. Radius
of hydrogen atom ground state.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p a0   \# 5.29177210903e{-}11}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a256}}{a256}}\label{a256}

\texttt{a256} --- color operations builtin. Alias for
\texttt{ansi\_256}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = a256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map a256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a3c\_advantage\_step}}{a3c\_advantage\_step}}\label{a3c_advantage_step}

\texttt{a3c\_advantage\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = a3c\_advantage\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map a3c\_advantage\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a85d}}{a85d}}\label{a85d}

\texttt{base85\_decode} (aliases \texttt{b85d}, \texttt{a85d}) decodes
an Ascii85/Base85 encoded string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p b85d(b85e("Hello"))  \# Hello}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a85e}}{a85e}}\label{a85e}

\texttt{base85\_encode} (aliases \texttt{b85e}, \texttt{a85e}) encodes a
string using Ascii85/Base85 encoding. More compact than Base64 (4:5
ratio vs 3:4).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p b85e("Hello")  \# encoded string}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a\_law\_decode}}{a\_law\_decode}}\label{a_law_decode}

\texttt{a\_law\_decode} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = a\_law\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map a\_law\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{a\_law\_encode}}{a\_law\_encode}}\label{a_law_encode}

\texttt{a\_law\_encode} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = a\_law\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map a\_law\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ab1\_step}}{ab1\_step}}\label{ab1_step}

\texttt{ab1\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ab1\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ab1\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ab2\_step}}{ab2\_step}}\label{ab2_step}

\texttt{ab2\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ab2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ab2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ab3\_step}}{ab3\_step}}\label{ab3_step}

\texttt{ab3\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ab3\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ab3\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ab4}}{ab4}}\label{ab4}

\texttt{ab4} --- batch 19 builtin. Alias for
\texttt{adams\_bashforth\_4}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ab4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ab4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ab\_coeff\_sum}}{ab\_coeff\_sum}}\label{ab_coeff_sum}

\texttt{ab\_coeff\_sum} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ab\_coeff\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ab\_coeff\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abelianization\_quotient}}{abelianization\_quotient}}\label{abelianization_quotient}

\texttt{abelianization\_quotient} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abelianization\_quotient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abelianization\_quotient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aberration\_annual}}{aberration\_annual}}\label{aberration_annual}

\texttt{aberration\_annual} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aberration\_annual $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aberration\_annual |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aberth\_step}}{aberth\_step}}\label{aberth_step}

\texttt{aberth\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aberth\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aberth\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abs\_ceil}}{abs\_ceil}}\label{abs_ceil}

\texttt{abs\_ceil} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abs\_ceil $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abs\_ceil |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abs\_diff}}{abs\_diff}}\label{abs_diff}

\texttt{abs\_diff} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abs\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abs\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abs\_each}}{abs\_each}}\label{abs_each}

\texttt{abs\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abs\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abs\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abs\_floor}}{abs\_floor}}\label{abs_floor}

\texttt{abs\_floor} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abs\_floor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abs\_floor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{absolute\_magnitude}}{absolute\_magnitude}}\label{absolute_magnitude}

\texttt{absolute\_magnitude} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = absolute\_magnitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map absolute\_magnitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{absolute\_vorticity\_step}}{absolute\_vorticity\_step}}\label{absolute_vorticity_step}

\texttt{absolute\_vorticity\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = absolute\_vorticity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map absolute\_vorticity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{absorbed\_short\_wave}}{absorbed\_short\_wave}}\label{absorbed_short_wave}

\texttt{absorbed\_short\_wave} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = absorbed\_short\_wave $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map absorbed\_short\_wave |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abundant\_numbers}}{abundant\_numbers}}\label{abundant_numbers}

\texttt{abundant\_numbers} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abundant\_numbers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abundant\_numbers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abunnums}}{abunnums}}\label{abunnums}

\texttt{abunnums} --- number theory / primes builtin. Alias for
\texttt{abundant\_numbers}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abunnums $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abunnums |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{abuse\_test\_voltage}}{abuse\_test\_voltage}}\label{abuse_test_voltage}

\texttt{abuse\_test\_voltage} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = abuse\_test\_voltage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map abuse\_test\_voltage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{accept\_lang\_pick}}{accept\_lang\_pick}}\label{accept_lang_pick}

\texttt{accept\_lang\_pick} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = accept\_lang\_pick $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map accept\_lang\_pick |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acceptance\_target}}{acceptance\_target}}\label{acceptance_target}

\texttt{acceptance\_target} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acceptance\_target $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acceptance\_target |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{accrint}}{accrint}}\label{accrint}

\texttt{accrint} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = accrint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map accrint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{accrued\_interest}}{accrued\_interest}}\label{accrued_interest}

\texttt{accrued\_interest} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = accrued\_interest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map accrued\_interest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{accum}}{accum}}\label{accum}

\texttt{accum} --- python/ruby stdlib builtin. Alias for
\texttt{accumulate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = accum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map accum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{accumulate}}{accumulate}}\label{accumulate}

\texttt{accumulate} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = accumulate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map accumulate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acf}}{acf}}\label{acf}

\texttt{acf\_fn} (alias \texttt{acf}) --- autocorrelation function.
Returns ACF values for lags 0..max\_lag. Like R\textquotesingle s acf().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = @\{acf([1,3,2,4,3,5,4,6], 5)\}}
\NormalTok{p $a[0]  \# 1.0 (lag 0 is always 1)}
\NormalTok{p $a[1]  \# lag{-}1 autocorrelation}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acf\_basis}}{acf\_basis}}\label{acf_basis}

\texttt{acf\_basis} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acf\_basis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acf\_basis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acirc}}{acirc}}\label{acirc}

\texttt{acirc} --- geometry / physics builtin. Alias for
\texttt{area\_circle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acirc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acirc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acorr}}{acorr}}\label{acorr}

\texttt{acorr} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{autocorrelation}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acorr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acorr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acos}}{acos}}\label{acos}

\texttt{acos} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acosh}}{acosh}}\label{acosh}

\texttt{acosh} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acosh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acosh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acot}}{acot}}\label{acot}

\texttt{acot} --- trig extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acro}}{acro}}\label{acro}

\texttt{acro} --- string processing (uncategorized batch) builtin. Alias
for \texttt{acronym}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acro $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acro |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acronym}}{acronym}}\label{acronym}

\texttt{acronym} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acronym $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acronym |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{acsc}}{acsc}}\label{acsc}

\texttt{acsc} --- trig extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = acsc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map acsc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adaboost\_alpha}}{adaboost\_alpha}}\label{adaboost_alpha}

\texttt{adaboost\_alpha} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adaboost\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adaboost\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adagrad\_step}}{adagrad\_step}}\label{adagrad_step}

\texttt{adagrad\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adagrad\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adagrad\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adams\_bashforth\_4}}{adams\_bashforth\_4}}\label{adams_bashforth_4}

\texttt{adams\_bashforth\_4} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adams\_bashforth\_4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adams\_bashforth\_4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{add\_days}}{add\_days}}\label{add_days}

\texttt{add\_days} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = add\_days $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map add\_days |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{add\_hours}}{add\_hours}}\label{add_hours}

\texttt{add\_hours} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = add\_hours $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map add\_hours |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{add\_minutes}}{add\_minutes}}\label{add_minutes}

\texttt{add\_minutes} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = add\_minutes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map add\_minutes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{addd}}{addd}}\label{addd}

\texttt{addd} --- extended stdlib builtin. Alias for \texttt{add\_days}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = addd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map addd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{addh}}{addh}}\label{addh}

\texttt{addh} --- extended stdlib builtin. Alias for
\texttt{add\_hours}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = addh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map addh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{addm}}{addm}}\label{addm}

\texttt{addm} --- extended stdlib builtin. Alias for
\texttt{add\_minutes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = addm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map addm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adf\_test\_stat}}{adf\_test\_stat}}\label{adf_test_stat}

\texttt{adf\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adf\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adf\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adfuller}}{adfuller}}\label{adfuller}

\texttt{adfuller} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adfuller $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adfuller |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adiabatic\_lapse\_rate\_dry}}{adiabatic\_lapse\_rate\_dry}}\label{adiabatic_lapse_rate_dry}

\texttt{adiabatic\_lapse\_rate\_dry} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adiabatic\_lapse\_rate\_dry $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adiabatic\_lapse\_rate\_dry |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adiabatic\_lapse\_rate\_moist}}{adiabatic\_lapse\_rate\_moist}}\label{adiabatic_lapse_rate_moist}

\texttt{adiabatic\_lapse\_rate\_moist} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adiabatic\_lapse\_rate\_moist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adiabatic\_lapse\_rate\_moist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adj\_r2}}{adj\_r2}}\label{adj_r2}

\texttt{adj\_r2} --- batch 9 builtin. Alias for
\texttt{adjusted\_r\_squared}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adj\_r2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adj\_r2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adjacent\_difference}}{adjacent\_difference}}\label{adjacent_difference}

\texttt{adjacent\_difference} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adjacent\_difference $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adjacent\_difference |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adjacent\_pairs}}{adjacent\_pairs}}\label{adjacent_pairs}

\texttt{adjacent\_pairs} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adjacent\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adjacent\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adjp}}{adjp}}\label{adjp}

\texttt{adjp} --- go/general functional utilities builtin. Alias for
\texttt{adjacent\_pairs}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adjp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adjp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adjusted\_r\_squared}}{adjusted\_r\_squared}}\label{adjusted_r_squared}

\texttt{adjusted\_r\_squared} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adjusted\_r\_squared $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adjusted\_r\_squared |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adjusted\_winner\_pct}}{adjusted\_winner\_pct}}\label{adjusted_winner_pct}

\texttt{adjusted\_winner\_pct} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adjusted\_winner\_pct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adjusted\_winner\_pct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adl32}}{adl32}}\label{adl32}

\texttt{adl32} --- extended stdlib builtin. Alias for \texttt{adler32}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adl32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adl32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adler32}}{adler32}}\label{adler32}

\texttt{adler32} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adler32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adler32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adler32\_hash}}{adler32\_hash}}\label{adler32_hash}

\texttt{adler32\_hash} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adler32\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adler32\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{adm\_mass\_step}}{adm\_mass\_step}}\label{adm_mass_step}

\texttt{adm\_mass\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = adm\_mass\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map adm\_mass\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{admm\_dual\_step}}{admm\_dual\_step}}\label{admm_dual_step}

\texttt{admm\_dual\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = admm\_dual\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map admm\_dual\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{admm\_primal\_step}}{admm\_primal\_step}}\label{admm_primal_step}

\texttt{admm\_primal\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = admm\_primal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map admm\_primal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ads\_metric\_step}}{ads\_metric\_step}}\label{ads_metric_step}

\texttt{ads\_metric\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ads\_metric\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ads\_metric\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aellip}}{aellip}}\label{aellip}

\texttt{aellip} --- geometry / physics builtin. Alias for
\texttt{area\_ellipse}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aellip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aellip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aerosol\_optical\_depth}}{aerosol\_optical\_depth}}\label{aerosol_optical_depth}

\texttt{aerosol\_optical\_depth} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aerosol\_optical\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aerosol\_optical\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aes\_inv\_sbox\_byte}}{aes\_inv\_sbox\_byte}}\label{aes_inv_sbox_byte}

\texttt{aes\_inv\_sbox\_byte} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aes\_inv\_sbox\_byte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aes\_inv\_sbox\_byte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aes\_sbox\_byte}}{aes\_sbox\_byte}}\label{aes_sbox_byte}

\texttt{aes\_sbox\_byte} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aes\_sbox\_byte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aes\_sbox\_byte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{affine\_encrypt}}{affine\_encrypt}}\label{affine_encrypt}

\texttt{affine\_encrypt} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = affine\_encrypt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map affine\_encrypt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{african\_monsoon\_index}}{african\_monsoon\_index}}\label{african_monsoon_index}

\texttt{african\_monsoon\_index} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = african\_monsoon\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map african\_monsoon\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{after\_n}}{after\_n}}\label{after_n}

\texttt{after\_n} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = after\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map after\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{age\_at\_date}}{age\_at\_date}}\label{age_at_date}

\texttt{age\_at\_date} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = age\_at\_date $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map age\_at\_date |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{age\_at\_z}}{age\_at\_z}}\label{age_at_z}

\texttt{age\_at\_z} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = age\_at\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map age\_at\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{age\_from\_birthdate}}{age\_from\_birthdate}}\label{age_from_birthdate}

\texttt{age\_from\_birthdate} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = age\_from\_birthdate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map age\_from\_birthdate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{age\_in\_years}}{age\_in\_years}}\label{age_in_years}

\texttt{age\_in\_years} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = age\_in\_years $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map age\_in\_years |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ageyrs}}{ageyrs}}\label{ageyrs}

\texttt{ageyrs} --- extended stdlib batch 3 builtin. Alias for
\texttt{age\_in\_years}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ageyrs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ageyrs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ai\_agent}}{ai\_agent}}\label{ai_agent}

\texttt{ai\_agent} --- ai primitives (docs/ai\_primitives.md) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ai\_agent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ai\_agent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aic}}{aic}}\label{aic}

\texttt{aic} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aig\_simplify\_step}}{aig\_simplify\_step}}\label{aig_simplify_step}

\texttt{aig\_simplify\_step} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aig\_simplify\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aig\_simplify\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ain}}{ain}}\label{ain}

\texttt{ain} --- algebraic match builtin. Alias for \texttt{assoc\_in}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{air\_mass\_kasten}}{air\_mass\_kasten}}\label{air_mass_kasten}

\texttt{air\_mass\_kasten} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = air\_mass\_kasten $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map air\_mass\_kasten |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{airy\_disk\_radius}}{airy\_disk\_radius}}\label{airy_disk_radius}

\texttt{airy\_disk\_radius} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = airy\_disk\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map airy\_disk\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{airyai}}{airyai}}\label{airyai}

\texttt{airyai} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = airyai $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map airyai |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{airybi}}{airybi}}\label{airybi}

\texttt{airybi} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = airybi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map airybi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aitken\_delta\_squared}}{aitken\_delta\_squared}}\label{aitken_delta_squared}

\texttt{aitken\_delta\_squared} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aitken\_delta\_squared $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aitken\_delta\_squared |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{akaike\_info\_crit}}{akaike\_info\_crit}}\label{akaike_info_crit}

\texttt{akaike\_info\_crit} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = akaike\_info\_crit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map akaike\_info\_crit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aks\_witness\_count}}{aks\_witness\_count}}\label{aks_witness_count}

\texttt{aks\_witness\_count} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aks\_witness\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aks\_witness\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{albedo\_blackbody\_balance}}{albedo\_blackbody\_balance}}\label{albedo_blackbody_balance}

\texttt{albedo\_blackbody\_balance} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = albedo\_blackbody\_balance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map albedo\_blackbody\_balance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{albers\_conic\_project}}{albers\_conic\_project}}\label{albers_conic_project}

\texttt{albers\_conic\_project} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = albers\_conic\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map albers\_conic\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alexander\_polynomial\_at\_one}}{alexander\_polynomial\_at\_one}}\label{alexander_polynomial_at_one}

\texttt{alexander\_polynomial\_at\_one} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = alexander\_polynomial\_at\_one $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map alexander\_polynomial\_at\_one |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alfven\_speed}}{alfven\_speed}}\label{alfven_speed}

\texttt{alfven\_speed} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = alfven\_speed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map alfven\_speed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{algebraic\_intersection\_number}}{algebraic\_intersection\_number}}\label{algebraic_intersection_number}

\texttt{algebraic\_intersection\_number} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = algebraic\_intersection\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map algebraic\_intersection\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aliquot\_sum}}{aliquot\_sum}}\label{aliquot_sum}

\texttt{aliquot\_sum} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aliquot\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aliquot\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{all\_distinct}}{all\_distinct}}\label{all_distinct}

\texttt{all\_distinct} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = all\_distinct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map all\_distinct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{all\_eq}}{all\_eq}}\label{all_eq}

\texttt{all\_eq} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = all\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map all\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{all\_match}}{all\_match}}\label{all_match}

\texttt{all\_match} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = all\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map all\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{all\_pay\_auction\_step}}{all\_pay\_auction\_step}}\label{all_pay_auction_step}

\texttt{all\_pay\_auction\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = all\_pay\_auction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map all\_pay\_auction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{all\_unique}}{all\_unique}}\label{all_unique}

\texttt{all\_unique} --- more list helpers builtin. Alias for
\texttt{all\_distinct}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = all\_unique $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map all\_unique |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{allee\_growth\_step}}{allee\_growth\_step}}\label{allee_growth_step}

\texttt{allee\_growth\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = allee\_growth\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map allee\_growth\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{allele\_frequency}}{allele\_frequency}}\label{allele_frequency}

\texttt{allele\_frequency} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = allele\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map allele\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alpha\_fs}}{alpha\_fs}}\label{alpha_fs}

\texttt{fine\_structure\_constant} (alias \texttt{alpha\_fs}) --- α ≈
1/137 ≈ 0.00730. Fundamental constant of electromagnetism.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p alpha\_fs       \# 0.0072973525693}
\NormalTok{p 1 / alpha\_fs   \# \textasciitilde{}137.036}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alt\_az\_to\_ra\_dec}}{alt\_az\_to\_ra\_dec}}\label{alt_az_to_ra_dec}

\texttt{alt\_az\_to\_ra\_dec} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = alt\_az\_to\_ra\_dec $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alternate\_case}}{alternate\_case}}\label{alternate_case}

\texttt{alternate\_case} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = alternate\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map alternate\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{alternating\_seq\_sum}}{alternating\_seq\_sum}}\label{alternating_seq_sum}

\texttt{alternating\_seq\_sum} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = alternating\_seq\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map alternating\_seq\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{always\_false}}{always\_false}}\label{always_false}

\texttt{always\_false} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = always\_false $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map always\_false |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{always\_true}}{always\_true}}\label{always_true}

\texttt{always\_true} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = always\_true $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map always\_true |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{am2\_step}}{am2\_step}}\label{am2_step}

\texttt{am2\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = am2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map am2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{am3\_step}}{am3\_step}}\label{am3_step}

\texttt{am3\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = am3\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map am3\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{am4\_step}}{am4\_step}}\label{am4_step}

\texttt{am4\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = am4\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map am4\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amari\_alpha\_div}}{amari\_alpha\_div}}\label{amari_alpha_div}

\texttt{amari\_alpha\_div} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amari\_alpha\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amari\_alpha\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amax}}{amax}}\label{amax}

\texttt{amax} --- extended stdlib builtin. Alias for \texttt{argmax}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amin}}{amin}}\label{amin}

\texttt{amin} --- extended stdlib builtin. Alias for \texttt{argmin}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amo\_index\_step}}{amo\_index\_step}}\label{amo_index_step}

\texttt{amo\_index\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amo\_index\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amo\_index\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amort}}{amort}}\label{amort}

\texttt{amortization\_schedule(\$principal,\ \$rate,\ \$periods)} (alias
\texttt{amort}) --- generates a full amortization schedule. Returns
arrayref of hashrefs with period, payment, principal, interest, balance.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sched = amort(10000, 0.05, 12)}
\NormalTok{for my $row (@$sched) \{}
\NormalTok{    p "Period $row{-}\textgreater{}\{period\}: bal=$row{-}\textgreater{}\{balance\}"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amortization\_total\_interest}}{amortization\_total\_interest}}\label{amortization_total_interest}

\texttt{amortization\_total\_interest} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amortization\_total\_interest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amortization\_total\_interest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amp\_to\_db}}{amp\_to\_db}}\label{amp_to_db}

\texttt{amp\_to\_db} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amp\_to\_db $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amphoteric\_check}}{amphoteric\_check}}\label{amphoteric_check}

\texttt{amphoteric\_check} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amphoteric\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amphoteric\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amplitude\_damping\_channel}}{amplitude\_damping\_channel}}\label{amplitude_damping_channel}

\texttt{amplitude\_damping\_channel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amplitude\_damping\_channel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amplitude\_damping\_channel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amplitude\_damping\_excited}}{amplitude\_damping\_excited}}\label{amplitude_damping_excited}

\texttt{amplitude\_damping\_excited} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amplitude\_damping\_excited $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amplitude\_damping\_excited |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{amu}}{amu}}\label{amu}

\texttt{amu} --- physics constants builtin. Alias for
\texttt{atomic\_mass\_unit}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = amu $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map amu |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{anagram\_q}}{anagram\_q}}\label{anagram_q}

\texttt{anagram\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = anagram\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map anagram\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{anaphora\_distance}}{anaphora\_distance}}\label{anaphora_distance}

\texttt{anaphora\_distance} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = anaphora\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map anaphora\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ancilla\_alloc}}{ancilla\_alloc}}\label{ancilla_alloc}

\texttt{ancilla\_alloc} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ancilla\_alloc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ancilla\_alloc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{and}}{and}}\label{and}

\texttt{and} --- control flow builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = and $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map and |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{and\_list}}{and\_list}}\label{and_list}

\texttt{and\_list} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = and\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map and\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{anderson\_darling}}{anderson\_darling}}\label{anderson_darling}

\texttt{anderson\_darling} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = anderson\_darling $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map anderson\_darling |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{anderson\_step}}{anderson\_step}}\label{anderson_step}

\texttt{anderson\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = anderson\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map anderson\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{andl}}{andl}}\label{andl}

\texttt{andl} --- additional missing stdlib functions builtin. Alias for
\texttt{and\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = andl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map andl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{andoyer\_dist}}{andoyer\_dist}}\label{andoyer_dist}

\texttt{andoyer\_dist} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = andoyer\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map andoyer\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{andrew\_monotone\_chain}}{andrew\_monotone\_chain}}\label{andrew_monotone_chain}

\texttt{andrew\_monotone\_chain} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = andrew\_monotone\_chain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map andrew\_monotone\_chain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angbet}}{angbet}}\label{angbet}

\texttt{angbet} --- geometry (extended) builtin. Alias for
\texttt{angle\_between}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = angbet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map angbet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angle\_between}}{angle\_between}}\label{angle_between}

\texttt{angle\_between(\$x1,\ \$y1,\ \$x2,\ \$y2)} --- computes the
angle in radians between two 2D vectors from origin. Returns the angle
using atan2.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $angle = angle\_between(1, 0, 0, 1)}
\NormalTok{p $angle   \# \textasciitilde{}1.5708 (π/2 radians = 90°)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angle\_between\_deg}}{angle\_between\_deg}}\label{angle_between_deg}

\texttt{angle\_between\_deg} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = angle\_between\_deg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map angle\_between\_deg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angle\_bracket}}{angle\_bracket}}\label{angle_bracket}

\texttt{angle\_bracket} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = angle\_bracket $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map angle\_bracket |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angular\_diameter\_distance}}{angular\_diameter\_distance}}\label{angular_diameter_distance}

\texttt{angular\_diameter\_distance} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = angular\_diameter\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map angular\_diameter\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angular\_velocity}}{angular\_velocity}}\label{angular_velocity}

\texttt{angular\_velocity} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = angular\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map angular\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{angvel}}{angvel}}\label{angvel}

\texttt{angvel} --- physics formulas builtin. Alias for
\texttt{angular\_velocity}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = angvel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map angvel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{annuity\_due\_an}}{annuity\_due\_an}}\label{annuity_due_an}

\texttt{annuity\_due\_an} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = annuity\_due\_an $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map annuity\_due\_an |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{annuity\_future\_value}}{annuity\_future\_value}}\label{annuity_future_value}

\texttt{annuity\_future\_value} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = annuity\_future\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map annuity\_future\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{annuity\_immediate\_an}}{annuity\_immediate\_an}}\label{annuity_immediate_an}

\texttt{annuity\_immediate\_an} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = annuity\_immediate\_an $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map annuity\_immediate\_an |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{annuity\_present\_value}}{annuity\_present\_value}}\label{annuity_present_value}

\texttt{annuity\_present\_value} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = annuity\_present\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map annuity\_present\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{anova}}{anova}}\label{anova}

\texttt{anova\_oneway} (aliases \texttt{anova}, \texttt{anova1})
performs one-way ANOVA. Returns {[}F-statistic, df\_between,
df\_within{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($F, $dfb, $dfw) = @\{anova([1,2,3], [4,5,6], [7,8,9])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_256}}{ansi\_256}}\label{ansi_256}

\texttt{ansi\_256} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_black}}{ansi\_black}}\label{ansi_black}

\texttt{ansi\_black} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_black $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_black |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_blue}}{ansi\_blue}}\label{ansi_blue}

\texttt{ansi\_blue} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_blue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_blue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_bold}}{ansi\_bold}}\label{ansi_bold}

\texttt{ansi\_bold} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_cyan}}{ansi\_cyan}}\label{ansi_cyan}

\texttt{ansi\_cyan} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_cyan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_cyan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_dim}}{ansi\_dim}}\label{ansi_dim}

\texttt{ansi\_dim} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_green}}{ansi\_green}}\label{ansi_green}

\texttt{ansi\_green} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_green $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_green |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_magenta}}{ansi\_magenta}}\label{ansi_magenta}

\texttt{ansi\_magenta} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_magenta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_magenta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_off}}{ansi\_off}}\label{ansi_off}

\texttt{ansi\_off} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_off $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_off |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_red}}{ansi\_red}}\label{ansi_red}

\texttt{ansi\_red} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_red $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_red |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_reverse}}{ansi\_reverse}}\label{ansi_reverse}

\texttt{ansi\_reverse} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_reverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_reverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_truecolor}}{ansi\_truecolor}}\label{ansi_truecolor}

\texttt{ansi\_truecolor} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_truecolor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_truecolor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_underline}}{ansi\_underline}}\label{ansi_underline}

\texttt{ansi\_underline} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_underline $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_underline |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_white}}{ansi\_white}}\label{ansi_white}

\texttt{ansi\_white} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ansi\_yellow}}{ansi\_yellow}}\label{ansi_yellow}

\texttt{ansi\_yellow} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ansi\_yellow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ansi\_yellow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{anti\_de\_sitter\_radius\_step}}{anti\_de\_sitter\_radius\_step}}\label{anti_de_sitter_radius_step}

\texttt{anti\_de\_sitter\_radius\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = anti\_de\_sitter\_radius\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map anti\_de\_sitter\_radius\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{antoine\_p}}{antoine\_p}}\label{antoine_p}

\texttt{antoine\_p} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = antoine\_p $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map antoine\_p |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{any\_match}}{any\_match}}\label{any_match}

\texttt{any\_match} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = any\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map any\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{aov}}{aov}}\label{aov}

\texttt{aov} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = aov $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map aov |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ap\_jonker\_volgenant\_step}}{ap\_jonker\_volgenant\_step}}\label{ap_jonker_volgenant_step}

\texttt{ap\_jonker\_volgenant\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ap\_jonker\_volgenant\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ap\_jonker\_volgenant\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apery}}{apery}}\label{apery}

\texttt{apery} --- math constants builtin. Alias for
\texttt{apery\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apery $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map apery |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apery\_constant}}{apery\_constant}}\label{apery_constant}

\texttt{apery\_constant} --- math constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apery\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map apery\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apparent\_horizon\_step}}{apparent\_horizon\_step}}\label{apparent_horizon_step}

\texttt{apparent\_horizon\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apparent\_horizon\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map apparent\_horizon\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{append\_elem}}{append\_elem}}\label{append_elem}

\texttt{append\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = append\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map append\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{append\_redis}}{append\_redis}}\label{append_redis}

\texttt{append\_redis} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = append\_redis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map append\_redis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{appl}}{appl}}\label{appl}

\texttt{appl} --- algebraic match builtin. Alias for \texttt{apply}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = appl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map appl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apply}}{apply}}\label{apply}

\texttt{apply} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apply\_list}}{apply\_list}}\label{apply_list}

\texttt{apply\_list} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apply\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map apply\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apply\_window}}{apply\_window}}\label{apply_window}

\texttt{apply\_window(\textbackslash{}@signal,\ \textbackslash{}@window)}
--- element-wise multiplies signal by window function. Use before FFT to
reduce spectral leakage.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $w = hann(scalar @signal)}
\NormalTok{my $windowed = apply\_window(\textbackslash{}@signal, $w)}
\NormalTok{my $spectrum = dft($windowed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{applywin}}{applywin}}\label{applywin}

\texttt{applywin} --- dsp / signal (extended) builtin. Alias for
\texttt{apply\_window}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = applywin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map applywin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{approval\_voting\_max}}{approval\_voting\_max}}\label{approval_voting_max}

\texttt{approval\_voting\_max} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = approval\_voting\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map approval\_voting\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{approx}}{approx}}\label{approx}

\texttt{approx\_fn} (alias \texttt{approx}) --- piecewise linear
interpolation at query points. Like R\textquotesingle s approx().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @y = @\{approx([0,1,2], [0,10,0], [0.5, 1.0, 1.5])\}}
\NormalTok{\# [5, 10, 5]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{approx\_eq}}{approx\_eq}}\label{approx_eq}

\texttt{approx\_eq} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = approx\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map approx\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{approximate\_entropy}}{approximate\_entropy}}\label{approximate_entropy}

\texttt{approximate\_entropy} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = approximate\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map approximate\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apr\_to\_apy}}{apr\_to\_apy}}\label{apr_to_apy}

\texttt{apr\_to\_apy} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apr\_to\_apy $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apsp}}{apsp}}\label{apsp}

\texttt{floyd\_warshall} (aliases \texttt{floydwarshall}, \texttt{apsp})
computes all-pairs shortest paths. Takes a distance matrix (use Inf for
no edge).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $d = apsp([[0,3,1e18],[1e18,0,1],[1e18,1e18,0]])}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{apy\_to\_apr}}{apy\_to\_apr}}\label{apy_to_apr}

\texttt{apy\_to\_apr} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = apy\_to\_apr $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ar\_model\_likelihood}}{ar\_model\_likelihood}}\label{ar_model_likelihood}

\texttt{ar\_model\_likelihood} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ar\_model\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ar\_model\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arange}}{arange}}\label{arange}

\texttt{arange} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arange $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arange |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arc\_length}}{arc\_length}}\label{arc_length}

\texttt{arc\_length(\$radius,\ \$theta)} --- computes the arc length of
a circular arc. Theta is the central angle in radians. Returns
\texttt{radius\ *\ theta}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p arc\_length(10, 3.14159)   \# \textasciitilde{}31.4 (half circle)}
\NormalTok{p arc\_length(5, 1.57)       \# \textasciitilde{}7.85 (quarter circle)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arch\_lm}}{arch\_lm}}\label{arch_lm}

\texttt{arch\_lm} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arch\_lm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arch\_lm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arch\_lm\_test}}{arch\_lm\_test}}\label{arch_lm_test}

\texttt{arch\_lm\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arch\_lm\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arch\_lm\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arclen}}{arclen}}\label{arclen}

\texttt{arclen} --- geometry (extended) builtin. Alias for
\texttt{arc\_length}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arclen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arclen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arctic\_oscillation\_step}}{arctic\_oscillation\_step}}\label{arctic_oscillation_step}

\texttt{arctic\_oscillation\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arctic\_oscillation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arctic\_oscillation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{area\_circle}}{area\_circle}}\label{area_circle}

\texttt{area\_circle} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = area\_circle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map area\_circle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{area\_ellipse}}{area\_ellipse}}\label{area_ellipse}

\texttt{area\_ellipse} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = area\_ellipse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map area\_ellipse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{area\_rectangle}}{area\_rectangle}}\label{area_rectangle}

\texttt{area\_rectangle} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = area\_rectangle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map area\_rectangle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{area\_trapezoid}}{area\_trapezoid}}\label{area_trapezoid}

\texttt{area\_trapezoid} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = area\_trapezoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map area\_trapezoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{area\_triangle}}{area\_triangle}}\label{area_triangle}

\texttt{area\_triangle} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = area\_triangle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map area\_triangle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arect}}{arect}}\label{arect}

\texttt{arect} --- geometry / physics builtin. Alias for
\texttt{area\_rectangle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arellano\_bond\_step}}{arellano\_bond\_step}}\label{arellano_bond_step}

\texttt{arellano\_bond\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arellano\_bond\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arellano\_bond\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argc}}{argc}}\label{argc}

\texttt{argc} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = argc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map argc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argmax}}{argmax}}\label{argmax}

\texttt{argmax} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = argmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map argmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argmin}}{argmin}}\label{argmin}

\texttt{argmin} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = argmin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map argmin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argon2\_block\_mix}}{argon2\_block\_mix}}\label{argon2_block_mix}

\texttt{argon2\_block\_mix} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = argon2\_block\_mix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map argon2\_block\_mix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argpartition}}{argpartition}}\label{argpartition}

\texttt{argpartition} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = argpartition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map argpartition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{argsort}}{argsort}}\label{argsort}

\texttt{argsort} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = argsort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map argsort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ari}}{ari}}\label{ari}

\texttt{ari} --- batch 9 builtin. Alias for
\texttt{automated\_readability\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ari $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ari |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arias\_intensity}}{arias\_intensity}}\label{arias_intensity}

\texttt{arias\_intensity} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arias\_intensity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arias\_intensity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arima\_diff}}{arima\_diff}}\label{arima_diff}

\texttt{arima\_diff} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arima\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arima\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arima\_fit}}{arima\_fit}}\label{arima_fit}

\texttt{arima\_fit} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arima\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arima\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arima\_forecast}}{arima\_forecast}}\label{arima_forecast}

\texttt{arima\_forecast} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arima\_forecast $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arima\_forecast |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arithmetic\_coding\_interval}}{arithmetic\_coding\_interval}}\label{arithmetic_coding_interval}

\texttt{arithmetic\_coding\_interval} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arithmetic\_coding\_interval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arithmetic\_coding\_interval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arithmetic\_decode\_interval}}{arithmetic\_decode\_interval}}\label{arithmetic_decode_interval}

\texttt{arithmetic\_decode\_interval} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arithmetic\_decode\_interval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arithmetic\_decode\_interval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arithmetic\_sequence}}{arithmetic\_sequence}}\label{arithmetic_sequence}

\texttt{arithmetic\_sequence} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arithmetic\_sequence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arithmetic\_sequence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arithmetic\_series}}{arithmetic\_series}}\label{arithmetic_series}

\texttt{arithmetic\_series(\$a1,\ \$d,\ \$n)} (alias \texttt{arithser})
--- sum of n terms of arithmetic sequence starting at a1 with common
difference d. Formula: n/2 × (2a1 + (n-1)d).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p arithser(1, 1, 100)    \# 5050 (1+2+...+100)}
\NormalTok{p arithser(2, 3, 10)     \# 155 (2+5+8+...+29)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arity\_of}}{arity\_of}}\label{arity_of}

\texttt{arity\_of} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arity\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arity\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arma\_model\_innovation}}{arma\_model\_innovation}}\label{arma_model_innovation}

\texttt{arma\_model\_innovation} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arma\_model\_innovation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arma\_model\_innovation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arma\_order\_select}}{arma\_order\_select}}\label{arma_order_select}

\texttt{arma\_order\_select} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arma\_order\_select $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arma\_order\_select |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{armstrong\_q}}{armstrong\_q}}\label{armstrong_q}

\texttt{armstrong\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = armstrong\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map armstrong\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_agg}}{array\_agg}}\label{array_agg}

\texttt{array\_agg} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_agg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_agg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_difference}}{array\_difference}}\label{array_difference}

\texttt{array\_difference} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_difference $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_difference |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_intersection}}{array\_intersection}}\label{array_intersection}

\texttt{array\_intersection} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_intersection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_intersection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_position}}{array\_position}}\label{array_position}

\texttt{array\_position} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_position $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_position |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_positions}}{array\_positions}}\label{array_positions}

\texttt{array\_positions} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_positions $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_positions |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_remove}}{array\_remove}}\label{array_remove}

\texttt{array\_remove} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_remove $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_remove |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_replace}}{array\_replace}}\label{array_replace}

\texttt{array\_replace} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_replace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_replace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_to\_hstore}}{array\_to\_hstore}}\label{array_to_hstore}

\texttt{array\_to\_hstore} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_to\_hstore $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_to\_jsonb}}{array\_to\_jsonb}}\label{array_to_jsonb}

\texttt{array\_to\_jsonb} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_to\_jsonb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_to\_string}}{array\_to\_string}}\label{array_to_string}

\texttt{array\_to\_string} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_to\_string $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{array\_union}}{array\_union}}\label{array_union}

\texttt{array\_union} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = array\_union $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map array\_union |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arrhenius\_k}}{arrhenius\_k}}\label{arrhenius_k}

\texttt{arrhenius\_k} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arrhenius\_k $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arrhenius\_k |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arrhenius\_temp\_q10}}{arrhenius\_temp\_q10}}\label{arrhenius_temp_q10}

\texttt{arrhenius\_temp\_q10} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arrhenius\_temp\_q10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arrhenius\_temp\_q10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arrow\_impossibility\_check}}{arrow\_impossibility\_check}}\label{arrow_impossibility_check}

\texttt{arrow\_impossibility\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arrow\_impossibility\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arrow\_impossibility\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arrow\_independence}}{arrow\_independence}}\label{arrow_independence}

\texttt{arrow\_independence} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arrow\_independence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map arrow\_independence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{arrow\_pareto\_check}}{arrow\_pareto\_check}}\label{arrow_pareto_check}

\texttt{arrow\_pareto\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = arrow\_pareto\_check $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{articulation\_point}}{articulation\_point}}\label{articulation_point}

\texttt{articulation\_point} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = articulation\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map articulation\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{articulation\_points}}{articulation\_points}}\label{articulation_points}

\texttt{articulation\_points} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = articulation\_points $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map articulation\_points |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ascent\_parser\_step}}{ascent\_parser\_step}}\label{ascent_parser_step}

\texttt{ascent\_parser\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ascent\_parser\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ascent\_parser\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ascii}}{ascii}}\label{ascii}

\texttt{ascii} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ascii $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ascii |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ascii\_chr}}{ascii\_chr}}\label{ascii_chr}

\texttt{ascii\_chr} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ascii\_chr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ascii\_chr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ascii\_ord}}{ascii\_ord}}\label{ascii_ord}

\texttt{ascii\_ord} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ascii\_ord $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ascii\_ord |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ascii\_table}}{ascii\_table}}\label{ascii_table}

\texttt{ascii\_table} --- batch 9 builtin. Alias for
\texttt{format\_table\_simple}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ascii\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ascii\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{asec}}{asec}}\label{asec}

\texttt{asec} --- trig extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = asec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map asec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{asian\_call\_mc}}{asian\_call\_mc}}\label{asian_call_mc}

\texttt{asian\_call\_mc} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = asian\_call\_mc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map asian\_call\_mc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{asin}}{asin}}\label{asin}

\texttt{asin} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = asin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map asin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{asinh}}{asinh}}\label{asinh}

\texttt{asinh} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = asinh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map asinh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{asrt}}{asrt}}\label{asrt}

\texttt{asrt} --- extended stdlib builtin. Alias for \texttt{argsort}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = asrt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map asrt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assert\_type}}{assert\_type}}\label{assert_type}

\texttt{assert\_type} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = assert\_type $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map assert\_type |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assignment\_lower\_bound}}{assignment\_lower\_bound}}\label{assignment_lower_bound}

\texttt{assignment\_lower\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = assignment\_lower\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map assignment\_lower\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assoc}}{assoc}}\label{assoc}

\texttt{assoc} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = assoc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map assoc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assoc\_fn}}{assoc\_fn}}\label{assoc_fn}

\texttt{assoc\_fn} --- go/general functional utilities builtin. Alias
for \texttt{associate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = assoc\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map assoc\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{assoc\_in}}{assoc\_in}}\label{assoc_in}

\texttt{assoc\_in} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = assoc\_in $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map assoc\_in |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{associate}}{associate}}\label{associate}

\texttt{associate} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = associate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map associate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{astar\_search}}{astar\_search}}\label{astar_search}

\texttt{astar\_search} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = astar\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map astar\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{astronomical\_unit}}{astronomical\_unit}}\label{astronomical_unit}

\texttt{astronomical\_unit} (alias \texttt{au}) --- AU ≈ 1.496×10¹¹ m.
Mean Earth-Sun distance.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p au             \# 1.495978707e11 m}
\NormalTok{p au / 1000      \# \textasciitilde{}149.6 million km}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{at\_content}}{at\_content}}\label{at_content}

\texttt{at\_content} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = at\_content $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map at\_content |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{at\_index}}{at\_index}}\label{at_index}

\texttt{at\_index} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = at\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map at\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atan}}{atan}}\label{atan}

\texttt{atan} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atanh}}{atanh}}\label{atanh}

\texttt{atanh} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atanh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atanh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atbash}}{atbash}}\label{atbash}

\texttt{atbash} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atbash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atbash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atbash\_cipher}}{atbash\_cipher}}\label{atbash_cipher}

\texttt{atbash\_cipher} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atbash\_cipher $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atbash\_cipher |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atc}}{atc}}\label{atc}

\texttt{atc} --- color operations builtin. Alias for
\texttt{ansi\_truecolor}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ati}}{ati}}\label{ati}

\texttt{ati} --- javascript array/object methods builtin. Alias for
\texttt{at\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ati $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ati |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atime}}{atime}}\label{atime}

\texttt{atime} --- file stat / path builtin. Alias for
\texttt{file\_atime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atm\_to\_pa}}{atm\_to\_pa}}\label{atm_to_pa}

\texttt{atm\_to\_pa} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atm\_to\_pa $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atomic\_mass\_unit}}{atomic\_mass\_unit}}\label{atomic_mass_unit}

\texttt{atomic\_mass\_unit} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atomic\_mass\_unit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atomic\_mass\_unit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atomic\_radius\_pm}}{atomic\_radius\_pm}}\label{atomic_radius_pm}

\texttt{atomic\_radius\_pm} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atomic\_radius\_pm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atomic\_radius\_pm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atrap}}{atrap}}\label{atrap}

\texttt{atrap} --- geometry / physics builtin. Alias for
\texttt{area\_trapezoid}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atrap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atrap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{atri}}{atri}}\label{atri}

\texttt{atri} --- geometry / physics builtin. Alias for
\texttt{area\_triangle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = atri $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map atri |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{attack\_rate}}{attack\_rate}}\label{attack_rate}

\texttt{attack\_rate} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = attack\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map attack\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{attempt}}{attempt}}\label{attempt}

\texttt{attempt} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = attempt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map attempt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{attributable\_fraction\_pop}}{attributable\_fraction\_pop}}\label{attributable_fraction_pop}

\texttt{attributable\_fraction\_pop} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = attributable\_fraction\_pop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map attributable\_fraction\_pop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{au\_to\_km}}{au\_to\_km}}\label{au_to_km}

\texttt{au\_to\_km} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = au\_to\_km $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{au\_to\_m}}{au\_to\_m}}\label{au_to_m}

\texttt{au\_to\_m} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = au\_to\_m $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{augmented\_lagrangian\_step}}{augmented\_lagrangian\_step}}\label{augmented_lagrangian_step}

\texttt{augmented\_lagrangian\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = augmented\_lagrangian\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map augmented\_lagrangian\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{autocorrelation}}{autocorrelation}}\label{autocorrelation}

\texttt{autocorrelation} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = autocorrelation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map autocorrelation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{automated\_readability\_index}}{automated\_readability\_index}}\label{automated_readability_index}

\texttt{automated\_readability\_index} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = automated\_readability\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map automated\_readability\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{average}}{average}}\label{average}

\texttt{average} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = average $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map average |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{averageif}}{averageif}}\label{averageif}

\texttt{averageif} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = averageif $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map averageif |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{averageifs}}{averageifs}}\label{averageifs}

\texttt{averageifs} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = averageifs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map averageifs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avg}}{avg}}\label{avg}

\texttt{avg} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avg\_degree}}{avg\_degree}}\label{avg_degree}

\texttt{avg\_degree} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avg\_degree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avg\_degree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avogadro}}{avogadro}}\label{avogadro}

\texttt{avogadro} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avogadro $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avogadro |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avogadro\_constant}}{avogadro\_constant}}\label{avogadro_constant}

\texttt{avogadro\_constant} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avogadro\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avogadro\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avogadro\_count}}{avogadro\_count}}\label{avogadro_count}

\texttt{avogadro\_count} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avogadro\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avogadro\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avogadro\_number}}{avogadro\_number}}\label{avogadro_number}

\texttt{avogadro\_number} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avogadro\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avogadro\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{avogadros\_number}}{avogadros\_number}}\label{avogadros_number}

\texttt{avogadros\_number} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = avogadros\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map avogadros\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{b2gray}}{b2gray}}\label{b2gray}

\texttt{b2gray} --- base / gray code builtin. Alias for
\texttt{binary\_to\_gray}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = b2gray $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map b2gray |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{b2i}}{b2i}}\label{b2i}

\texttt{b2i} --- boolean combinators builtin. Alias for
\texttt{bool\_to\_int}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = b2i $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map b2i |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{b64d}}{b64d}}\label{b64d}

\texttt{b64d} --- crypto / encoding builtin. Alias for
\texttt{base64\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = b64d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map b64d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{b64e}}{b64e}}\label{b64e}

\texttt{b64e} --- crypto / encoding builtin. Alias for
\texttt{base64\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = b64e $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map b64e |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{b\_to\_kb}}{b\_to\_kb}}\label{b_to_kb}

\texttt{b\_to\_kb} --- unit conversions builtin. Alias for
\texttt{bytes\_to\_kb}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = b\_to\_kb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{b\_wien}}{b\_wien}}\label{b_wien}

\texttt{b\_wien} --- physics constants builtin. Alias for
\texttt{wien\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = b\_wien $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map b\_wien |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{babip}}{babip}}\label{babip}

\texttt{babip} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = babip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map babip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bac}}{bac}}\label{bac}

\texttt{bac} --- finance builtin. Alias for \texttt{bac\_estimate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bac $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bac |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bac\_estimate}}{bac\_estimate}}\label{bac_estimate}

\texttt{bac\_estimate} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bac\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bac\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bachelier\_call}}{bachelier\_call}}\label{bachelier_call}

\texttt{bachelier\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bachelier\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bachelier\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{backward\_euler}}{backward\_euler}}\label{backward_euler}

\texttt{backward\_euler} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = backward\_euler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map backward\_euler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{badi\_year\_from\_fixed}}{badi\_year\_from\_fixed}}\label{badi_year_from_fixed}

\texttt{badi\_year\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = badi\_year\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map badi\_year\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bahai\_from\_fixed}}{bahai\_from\_fixed}}\label{bahai_from_fixed}

\texttt{bahai\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bahai\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bahai\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bairstow}}{bairstow}}\label{bairstow}

\texttt{bairstow} --- batch 10 builtin. Alias for
\texttt{lin\_bairstow\_step}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bairstow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bairstow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{balanced\_accuracy}}{balanced\_accuracy}}\label{balanced_accuracy}

\texttt{balanced\_accuracy} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = balanced\_accuracy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map balanced\_accuracy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bandpass\_filter}}{bandpass\_filter}}\label{bandpass_filter}

\texttt{bandpass\_filter(\textbackslash{}@signal,\ \$low,\ \$high)}
(alias \texttt{bpf}) --- applies a band-pass filter passing frequencies
between low and high cutoffs. Combines low-pass and high-pass.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $filtered = bpf(\textbackslash{}@signal, 0.1, 0.3)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{banzhaf\_index\_two}}{banzhaf\_index\_two}}\label{banzhaf_index_two}

\texttt{banzhaf\_index\_two} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = banzhaf\_index\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map banzhaf\_index\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bao\_scale\_today}}{bao\_scale\_today}}\label{bao_scale_today}

\texttt{bao\_scale\_today} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bao\_scale\_today $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bao\_scale\_today |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bar\_to\_pascals}}{bar\_to\_pascals}}\label{bar_to_pascals}

\texttt{bar\_to\_pascals} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bar\_to\_pascals $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bargaining\_set\_check}}{bargaining\_set\_check}}\label{bargaining_set_check}

\texttt{bargaining\_set\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bargaining\_set\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bargaining\_set\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{barrier\_up\_out\_call}}{barrier\_up\_out\_call}}\label{barrier_up_out_call}

\texttt{barrier\_up\_out\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = barrier\_up\_out\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map barrier\_up\_out\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{barthann\_w}}{barthann\_w}}\label{barthann_w}

\texttt{barthann\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = barthann\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map barthann\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bartlett\_window}}{bartlett\_window}}\label{bartlett_window}

\texttt{bartlett\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bartlett\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bartlett\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{base\_convert}}{base\_convert}}\label{base_convert}

\texttt{base\_convert} --- base / gray code builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = base\_convert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map base\_convert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{batch}}{batch}}\label{batch}

\texttt{batch} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = batch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map batch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{batched}}{batched}}\label{batched}

\texttt{batched} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = batched $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map batched |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{batchelor\_scale\_step}}{batchelor\_scale\_step}}\label{batchelor_scale_step}

\texttt{batchelor\_scale\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = batchelor\_scale\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map batchelor\_scale\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{battle\_sexes\_payoff}}{battle\_sexes\_payoff}}\label{battle_sexes_payoff}

\texttt{battle\_sexes\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = battle\_sexes\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map battle\_sexes\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bauer\_furuta\_step}}{bauer\_furuta\_step}}\label{bauer_furuta_step}

\texttt{bauer\_furuta\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bauer\_furuta\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bauer\_furuta\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bayes\_posterior}}{bayes\_posterior}}\label{bayes_posterior}

\texttt{bayes\_posterior} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bayes\_posterior $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bayes\_posterior |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bayesian\_info\_crit}}{bayesian\_info\_crit}}\label{bayesian_info_crit}

\texttt{bayesian\_info\_crit} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bayesian\_info\_crit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bayesian\_info\_crit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bayesian\_step}}{bayesian\_step}}\label{bayesian_step}

\texttt{bayesian\_step} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bayesian\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bayesian\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bbox}}{bbox}}\label{bbox}

\texttt{bounding\_box(@points)} (alias \texttt{bbox}) --- computes the
axis-aligned bounding box of 2D points. Returns {[}min\_x, min\_y,
max\_x, max\_y{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @pts = (1,2, 3,4, 0,1, 5,3)}
\NormalTok{my $bb = bbox(@pts)}
\NormalTok{p @$bb   \# (0, 1, 5, 4)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bbox\_from\_points}}{bbox\_from\_points}}\label{bbox_from_points}

\texttt{bbox\_from\_points} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bbox\_from\_points $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bbox\_from\_points |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bconv}}{bconv}}\label{bconv}

\texttt{bconv} --- base / gray code builtin. Alias for
\texttt{base\_convert}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bconv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bconv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bcount}}{bcount}}\label{bcount}

\texttt{bcount} --- extended stdlib batch 3 builtin. Alias for
\texttt{count\_bytes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bcrypt\_cost\_iters}}{bcrypt\_cost\_iters}}\label{bcrypt_cost_iters}

\texttt{bcrypt\_cost\_iters} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bcrypt\_cost\_iters $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bcrypt\_cost\_iters |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdd\_apply}}{bdd\_apply}}\label{bdd_apply}

\texttt{bdd\_apply} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdd\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdd\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdd\_quantify}}{bdd\_quantify}}\label{bdd_quantify}

\texttt{bdd\_quantify} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdd\_quantify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdd\_quantify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdd\_restrict}}{bdd\_restrict}}\label{bdd_restrict}

\texttt{bdd\_restrict} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdd\_restrict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdd\_restrict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdf1\_step}}{bdf1\_step}}\label{bdf1_step}

\texttt{bdf1\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdf1\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdf1\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdf2\_step}}{bdf2\_step}}\label{bdf2_step}

\texttt{bdf2\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdf2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdf2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdf3\_step}}{bdf3\_step}}\label{bdf3_step}

\texttt{bdf3\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdf3\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdf3\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdf4\_step}}{bdf4\_step}}\label{bdf4_step}

\texttt{bdf4\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdf4\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdf4\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdf5\_step}}{bdf5\_step}}\label{bdf5_step}

\texttt{bdf5\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdf5\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdf5\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bdf6\_step}}{bdf6\_step}}\label{bdf6_step}

\texttt{bdf6\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bdf6\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bdf6\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bearing}}{bearing}}\label{bearing}

\texttt{bearing} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bearing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bearing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{beat\_frequency}}{beat\_frequency}}\label{beat_frequency}

\texttt{beat\_frequency} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = beat\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map beat\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{beat\_to\_seconds}}{beat\_to\_seconds}}\label{beat_to_seconds}

\texttt{beat\_to\_seconds} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = beat\_to\_seconds $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{beaufort}}{beaufort}}\label{beaufort}

\texttt{beaufort} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = beaufort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map beaufort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{before\_n}}{before\_n}}\label{before_n}

\texttt{before\_n} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = before\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map before\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bekenstein\_entropy\_step}}{bekenstein\_entropy\_step}}\label{bekenstein_entropy_step}

\texttt{bekenstein\_entropy\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bekenstein\_entropy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bekenstein\_entropy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bell\_inequality\_chsh}}{bell\_inequality\_chsh}}\label{bell_inequality_chsh}

\texttt{bell\_inequality\_chsh} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bell\_inequality\_chsh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bell\_inequality\_chsh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bell\_number}}{bell\_number}}\label{bell_number}

\texttt{bell\_number} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bell\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bell\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bell\_state}}{bell\_state}}\label{bell_state}

\texttt{bell\_state} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bell\_state $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bell\_state |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bell\_state\_index}}{bell\_state\_index}}\label{bell_state_index}

\texttt{bell\_state\_index} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bell\_state\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bell\_state\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bellman\_equation\_step}}{bellman\_equation\_step}}\label{bellman_equation_step}

\texttt{bellman\_equation\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bellman\_equation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bellman\_equation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bellman\_ford}}{bellman\_ford}}\label{bellman_ford}

\texttt{bellman\_ford} (alias \texttt{bellmanford}) computes shortest
paths from a source in a graph with negative weights. Takes edges
{[}{[}u,v,w{]},...{]}, node count, source index.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $d = bellmanford([[0,1,4],[0,2,5],[1,2,{-}3]], 3, 0)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bellman\_ford\_relax}}{bellman\_ford\_relax}}\label{bellman_ford_relax}

\texttt{bellman\_ford\_relax} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bellman\_ford\_relax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bellman\_ford\_relax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{belln}}{belln}}\label{belln}

\texttt{belln} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{bell\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = belln $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map belln |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{benders\_decomposition\_step}}{benders\_decomposition\_step}}\label{benders_decomposition_step}

\texttt{benders\_decomposition\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = benders\_decomposition\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map benders\_decomposition\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{berger\_parker}}{berger\_parker}}\label{berger_parker}

\texttt{berger\_parker} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = berger\_parker $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map berger\_parker |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bergmann\_adjust}}{bergmann\_adjust}}\label{bergmann_adjust}

\texttt{bergmann\_adjust} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bergmann\_adjust $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bergmann\_adjust |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bernoulli}}{bernoulli}}\label{bernoulli}

\texttt{bernoulli\_number} (alias \texttt{bernoulli}) computes the nth
Bernoulli number. B(0)=1, B(1)=-0.5, odd B(n\textgreater1)=0.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bernoulli(0)   \# 1}
\NormalTok{p bernoulli(2)   \# 0.1667}
\NormalTok{p bernoulli(4)   \# {-}0.0333}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{berry\_phase\_spin\_half}}{berry\_phase\_spin\_half}}\label{berry_phase_spin_half}

\texttt{berry\_phase\_spin\_half} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = berry\_phase\_spin\_half $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map berry\_phase\_spin\_half |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bertrand\_eq}}{bertrand\_eq}}\label{bertrand_eq}

\texttt{bertrand\_eq} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bertrand\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bertrand\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bertrand\_price\_step}}{bertrand\_price\_step}}\label{bertrand_price_step}

\texttt{bertrand\_price\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bertrand\_price\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bertrand\_price\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_in\_general}}{bessel\_in\_general}}\label{bessel_in_general}

\texttt{bessel\_in\_general} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bessel\_in\_general $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bessel\_in\_general |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_jn\_general}}{bessel\_jn\_general}}\label{bessel_jn_general}

\texttt{bessel\_jn\_general} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bessel\_jn\_general $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bessel\_jn\_general |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bessel\_lp}}{bessel\_lp}}\label{bessel_lp}

\texttt{bessel\_lp} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bessel\_lp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bessel\_lp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{best\_response\_dynamic}}{best\_response\_dynamic}}\label{best_response_dynamic}

\texttt{best\_response\_dynamic} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = best\_response\_dynamic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map best\_response\_dynamic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{beta\_pdf}}{beta\_pdf}}\label{beta_pdf}

\texttt{beta\_pdf} (alias \texttt{betapdf}) evaluates the Beta
distribution PDF at x with shape parameters alpha and beta.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p betapdf(0.5, 2, 5)  \# Beta(2,5) at x=0.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{betti\_one}}{betti\_one}}\label{betti_one}

\texttt{betti\_one} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = betti\_one $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map betti\_one |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{betti\_two}}{betti\_two}}\label{betti_two}

\texttt{betti\_two} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = betti\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map betti\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{betti\_zero}}{betti\_zero}}\label{betti_zero}

\texttt{betti\_zero} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = betti\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map betti\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{between}}{between}}\label{between}

\texttt{between} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{beylkin\_wavelet\_step}}{beylkin\_wavelet\_step}}\label{beylkin_wavelet_step}

\texttt{beylkin\_wavelet\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = beylkin\_wavelet\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map beylkin\_wavelet\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfgs\_h\_update\_1d}}{bfgs\_h\_update\_1d}}\label{bfgs_h_update_1d}

\texttt{bfgs\_h\_update\_1d} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfgs\_h\_update\_1d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfgs\_h\_update\_1d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfield\_solenoid}}{bfield\_solenoid}}\label{bfield_solenoid}

\texttt{bfield\_solenoid} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfield\_solenoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfield\_solenoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfield\_wire}}{bfield\_wire}}\label{bfield_wire}

\texttt{bfield\_wire} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfield\_wire $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfield\_wire |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfs}}{bfs}}\label{bfs}

\texttt{bfs} --- extended stdlib builtin. Alias for
\texttt{bfs\_traverse}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfs\_count}}{bfs\_count}}\label{bfs_count}

\texttt{bfs\_count} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfs\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfs\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfs\_distances}}{bfs\_distances}}\label{bfs_distances}

\texttt{bfs\_distances} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfs\_distances $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfs\_distances |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bfs\_traverse}}{bfs\_traverse}}\label{bfs_traverse}

\texttt{bfs\_traverse} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bfs\_traverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bfs\_traverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_black}}{bg\_black}}\label{bg_black}

\texttt{bg\_black} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_black $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_black |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_blue}}{bg\_blue}}\label{bg_blue}

\texttt{bg\_blue} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_blue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_blue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_blue}}{bg\_bright\_blue}}\label{bg_bright_blue}

\texttt{bg\_bright\_blue} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_blue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_blue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_cyan}}{bg\_bright\_cyan}}\label{bg_bright_cyan}

\texttt{bg\_bright\_cyan} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_cyan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_cyan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_green}}{bg\_bright\_green}}\label{bg_bright_green}

\texttt{bg\_bright\_green} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_green $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_green |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_magenta}}{bg\_bright\_magenta}}\label{bg_bright_magenta}

\texttt{bg\_bright\_magenta} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_magenta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_magenta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_red}}{bg\_bright\_red}}\label{bg_bright_red}

\texttt{bg\_bright\_red} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_red $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_red |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_white}}{bg\_bright\_white}}\label{bg_bright_white}

\texttt{bg\_bright\_white} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_bright\_yellow}}{bg\_bright\_yellow}}\label{bg_bright_yellow}

\texttt{bg\_bright\_yellow} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_bright\_yellow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_bright\_yellow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_c256}}{bg\_c256}}\label{bg_c256}

\texttt{bg\_c256} --- color / ansi builtin. Alias for
\texttt{bg\_color256}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_c256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_c256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_color256}}{bg\_color256}}\label{bg_color256}

\texttt{bg\_color256} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_color256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_color256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_cyan}}{bg\_cyan}}\label{bg_cyan}

\texttt{bg\_cyan} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_cyan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_cyan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_green}}{bg\_green}}\label{bg_green}

\texttt{bg\_green} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_green $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_green |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_magenta}}{bg\_magenta}}\label{bg_magenta}

\texttt{bg\_magenta} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_magenta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_magenta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_red}}{bg\_red}}\label{bg_red}

\texttt{bg\_red} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_red $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_red |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_rgb}}{bg\_rgb}}\label{bg_rgb}

\texttt{bg\_rgb} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_rgb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_rgb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_white}}{bg\_white}}\label{bg_white}

\texttt{bg\_white} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bg\_yellow}}{bg\_yellow}}\label{bg_yellow}

\texttt{bg\_yellow} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bg\_yellow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bg\_yellow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bh\_adjusted\_p}}{bh\_adjusted\_p}}\label{bh_adjusted_p}

\texttt{bh\_adjusted\_p} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bh\_adjusted\_p $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bh\_adjusted\_p |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bh\_entropy}}{bh\_entropy}}\label{bh_entropy}

\texttt{bh\_entropy} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bh\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bh\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bh\_evaporation\_time}}{bh\_evaporation\_time}}\label{bh_evaporation_time}

\texttt{bh\_evaporation\_time} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bh\_evaporation\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bh\_evaporation\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bhattacharyya\_coefficient}}{bhattacharyya\_coefficient}}\label{bhattacharyya_coefficient}

\texttt{bhattacharyya\_coefficient} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bhattacharyya\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bhattacharyya\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bianchi\_first\_identity\_check}}{bianchi\_first\_identity\_check}}\label{bianchi_first_identity_check}

\texttt{bianchi\_first\_identity\_check} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bianchi\_first\_identity\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bianchi\_first\_identity\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bianchi\_second\_identity\_check}}{bianchi\_second\_identity\_check}}\label{bianchi_second_identity_check}

\texttt{bianchi\_second\_identity\_check} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bianchi\_second\_identity\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bianchi\_second\_identity\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bic}}{bic}}\label{bic}

\texttt{bic} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biconnected\_components}}{biconnected\_components}}\label{biconnected_components}

\texttt{biconnected\_components} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biconnected\_components $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biconnected\_components |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bidirectional\_dijkstra}}{bidirectional\_dijkstra}}\label{bidirectional_dijkstra}

\texttt{bidirectional\_dijkstra} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bidirectional\_dijkstra $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bidirectional\_dijkstra |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bielliptic\_total}}{bielliptic\_total}}\label{bielliptic_total}

\texttt{bielliptic\_total} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bielliptic\_total $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bielliptic\_total |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bigram}}{bigram}}\label{bigram}

\texttt{bigram} --- string processing (uncategorized batch) builtin.
Alias for \texttt{bigrams}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bigram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bigram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bigram\_perplexity}}{bigram\_perplexity}}\label{bigram_perplexity}

\texttt{bigram\_perplexity} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bigram\_perplexity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bigram\_perplexity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bigrams}}{bigrams}}\label{bigrams}

\texttt{bigrams} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bigrams $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bigrams |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bilinear\_xform}}{bilinear\_xform}}\label{bilinear_xform}

\texttt{bilinear\_xform} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bilinear\_xform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bilinear\_xform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bilinear\_zpk\_xform}}{bilinear\_zpk\_xform}}\label{bilinear_zpk_xform}

\texttt{bilinear\_zpk\_xform} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bilinear\_zpk\_xform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bilinear\_zpk\_xform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bin\_of}}{bin\_of}}\label{bin_of}

\texttt{bin\_of} --- base conversion builtin. Alias for
\texttt{to\_bin}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bin\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bin\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bin\_packing\_best\_fit}}{bin\_packing\_best\_fit}}\label{bin_packing_best_fit}

\texttt{bin\_packing\_best\_fit} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bin\_packing\_best\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bin\_packing\_best\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bin\_packing\_first\_fit}}{bin\_packing\_first\_fit}}\label{bin_packing_first_fit}

\texttt{bin\_packing\_first\_fit} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bin\_packing\_first\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bin\_packing\_first\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bin\_packing\_lower\_bound\_l1}}{bin\_packing\_lower\_bound\_l1}}\label{bin_packing_lower_bound_l1}

\texttt{bin\_packing\_lower\_bound\_l1} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bin\_packing\_lower\_bound\_l1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bin\_packing\_lower\_bound\_l1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bin\_packing\_next\_fit}}{bin\_packing\_next\_fit}}\label{bin_packing_next_fit}

\texttt{bin\_packing\_next\_fit} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bin\_packing\_next\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bin\_packing\_next\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bin\_to\_gray}}{bin\_to\_gray}}\label{bin_to_gray}

\texttt{bin\_to\_gray} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bin\_to\_gray $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binary\_insert}}{binary\_insert}}\label{binary_insert}

\texttt{binary\_insert} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binary\_insert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map binary\_insert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binary\_search}}{binary\_search}}\label{binary_search}

\texttt{binary\_search} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binary\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map binary\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binary\_to\_gray}}{binary\_to\_gray}}\label{binary_to_gray}

\texttt{binary\_to\_gray} --- base / gray code builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binary\_to\_gray $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bincount}}{bincount}}\label{bincount}

\texttt{bincount} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bincount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bincount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binder\_content\_optimal}}{binder\_content\_optimal}}\label{binder_content_optimal}

\texttt{binder\_content\_optimal} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binder\_content\_optimal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map binder\_content\_optimal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binom}}{binom}}\label{binom}

\texttt{binom} --- extended stdlib batch 3 builtin. Alias for
\texttt{binomial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binom $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map binom |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binom\_test}}{binom\_test}}\label{binom_test}

\texttt{binom\_test} --- exact binomial test. Returns two-sided p-value.
Like R\textquotesingle s binom.test().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $p = binomtest(7, 10, 0.5)  \# p{-}value for 7/10 successes vs p=0.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binomial}}{binomial}}\label{binomial}

\texttt{binomial} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binomial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map binomial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{binsert}}{binsert}}\label{binsert}

\texttt{binsert} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{binary\_insert}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = binsert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map binsert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biorthogonal\_step}}{biorthogonal\_step}}\label{biorthogonal_step}

\texttt{biorthogonal\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biorthogonal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biorthogonal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biot\_number\_step}}{biot\_number\_step}}\label{biot_number_step}

\texttt{biot\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biot\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biot\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_allpass\_coeffs}}{biquad\_allpass\_coeffs}}\label{biquad_allpass_coeffs}

\texttt{biquad\_allpass\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_allpass\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_allpass\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_bandpass\_coeffs}}{biquad\_bandpass\_coeffs}}\label{biquad_bandpass_coeffs}

\texttt{biquad\_bandpass\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_bandpass\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_bandpass\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_highpass\_coeffs}}{biquad\_highpass\_coeffs}}\label{biquad_highpass_coeffs}

\texttt{biquad\_highpass\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_highpass\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_highpass\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_highshelf\_coeffs}}{biquad\_highshelf\_coeffs}}\label{biquad_highshelf_coeffs}

\texttt{biquad\_highshelf\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_highshelf\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_highshelf\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_lowpass\_coeffs}}{biquad\_lowpass\_coeffs}}\label{biquad_lowpass_coeffs}

\texttt{biquad\_lowpass\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_lowpass\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_lowpass\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_lowshelf\_coeffs}}{biquad\_lowshelf\_coeffs}}\label{biquad_lowshelf_coeffs}

\texttt{biquad\_lowshelf\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_lowshelf\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_lowshelf\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_notch\_coeffs}}{biquad\_notch\_coeffs}}\label{biquad_notch_coeffs}

\texttt{biquad\_notch\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_notch\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_notch\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_peak\_coeffs}}{biquad\_peak\_coeffs}}\label{biquad_peak_coeffs}

\texttt{biquad\_peak\_coeffs} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_peak\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_peak\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{biquad\_step}}{biquad\_step}}\label{biquad_step}

\texttt{biquad\_step} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = biquad\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map biquad\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{birnbaum\_saunders\_pdf}}{birnbaum\_saunders\_pdf}}\label{birnbaum_saunders_pdf}

\texttt{birnbaum\_saunders\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = birnbaum\_saunders\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map birnbaum\_saunders\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bisect}}{bisect}}\label{bisect}

\texttt{bisection} (alias \texttt{bisect}) finds a root of f(x)=0 in
{[}a,b{]} via the bisection method. Takes a code ref, a, b, and optional
tolerance.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $root = bisect(fn \{ $\_[0]**2 {-} 2 \}, 1, 2)  \# √2 ≈ 1.4142}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bisimulation\_step}}{bisimulation\_step}}\label{bisimulation_step}

\texttt{bisimulation\_step} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bisimulation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bisimulation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_and}}{bit\_and}}\label{bit_and}

\texttt{bit\_and} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_and $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_and |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_build}}{bit\_build}}\label{bit_build}

\texttt{bit\_build} --- batch 10 builtin. Alias for
\texttt{fenwick\_build}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_build $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_build |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_clear}}{bit\_clear}}\label{bit_clear}

\texttt{bit\_clear} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_flip\_prob}}{bit\_flip\_prob}}\label{bit_flip_prob}

\texttt{bit\_flip\_prob} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_flip\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_flip\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_length}}{bit\_length}}\label{bit_length}

\texttt{bit\_length} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_not}}{bit\_not}}\label{bit_not}

\texttt{bit\_not} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_not $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_not |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_or}}{bit\_or}}\label{bit_or}

\texttt{bit\_or} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_or $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_or |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_query}}{bit\_query}}\label{bit_query}

\texttt{bit\_query} --- batch 10 builtin. Alias for
\texttt{fenwick\_query}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_query $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_query |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_reverse}}{bit\_reverse}}\label{bit_reverse}

\texttt{bit\_reverse} --- batch 10 builtin. Alias for
\texttt{bit\_reverse\_32}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_reverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_reverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_reverse\_32}}{bit\_reverse\_32}}\label{bit_reverse_32}

\texttt{bit\_reverse\_32} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_reverse\_32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_reverse\_32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_reverse\_64}}{bit\_reverse\_64}}\label{bit_reverse_64}

\texttt{bit\_reverse\_64} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_reverse\_64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_reverse\_64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_set}}{bit\_set}}\label{bit_set}

\texttt{bit\_set} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_test}}{bit\_test}}\label{bit_test}

\texttt{bit\_test} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_toggle}}{bit\_toggle}}\label{bit_toggle}

\texttt{bit\_toggle} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_toggle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_toggle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bit\_xor}}{bit\_xor}}\label{bit_xor}

\texttt{bit\_xor} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bit\_xor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bit\_xor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitcount}}{bitcount}}\label{bitcount}

\texttt{bitcount} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitlen}}{bitlen}}\label{bitlen}

\texttt{bitlen} --- base conversion builtin. Alias for
\texttt{bit\_length}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitlen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitlen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitop}}{bitop}}\label{bitop}

\texttt{bitop} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitpos}}{bitpos}}\label{bitpos}

\texttt{bitpos} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitpos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitpos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bits\_count}}{bits\_count}}\label{bits_count}

\texttt{bits\_count} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bits\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bits\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bits\_to\_bytes}}{bits\_to\_bytes}}\label{bits_to_bytes}

\texttt{bits\_to\_bytes} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bits\_to\_bytes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitset\_clear}}{bitset\_clear}}\label{bitset_clear}

\texttt{bitset\_clear} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitset\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitset\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitset\_new}}{bitset\_new}}\label{bitset_new}

\texttt{bitset\_new} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitset\_new $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitset\_new |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitset\_set}}{bitset\_set}}\label{bitset_set}

\texttt{bitset\_set} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitset\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitset\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bitset\_test}}{bitset\_test}}\label{bitset_test}

\texttt{bitset\_test} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bitset\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bitset\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bkt}}{bkt}}\label{bkt}

\texttt{bkt} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{bucket}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bkt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bkt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bl}}{bl}}\label{bl}

\texttt{bl} --- algebraic match builtin. Alias for \texttt{butlast}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{black}}{black}}\label{black}

\texttt{black} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = black $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map black |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{black76\_call}}{black76\_call}}\label{black76_call}

\texttt{black76\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = black76\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map black76\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{black\_karasinski\_drift}}{black\_karasinski\_drift}}\label{black_karasinski_drift}

\texttt{black\_karasinski\_drift} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = black\_karasinski\_drift $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map black\_karasinski\_drift |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{black\_method\_winner}}{black\_method\_winner}}\label{black_method_winner}

\texttt{black\_method\_winner} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = black\_method\_winner $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map black\_method\_winner |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{black\_scholes\_call}}{black\_scholes\_call}}\label{black_scholes_call}

\texttt{black\_scholes\_call(\$S,\ \$K,\ \$r,\ \$T,\ \$sigma)} (alias
\texttt{bscall}) --- computes Black-Scholes price for a European call
option. S=spot, K=strike, r=rate, T=time to expiry, sigma=volatility.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bscall(100, 100, 0.05, 1, 0.2)   \# \textasciitilde{}10.45}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{black\_scholes\_put}}{black\_scholes\_put}}\label{black_scholes_put}

\texttt{black\_scholes\_put(\$S,\ \$K,\ \$r,\ \$T,\ \$sigma)} (alias
\texttt{bsput}) --- computes Black-Scholes price for a European put
option.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bsput(100, 100, 0.05, 1, 0.2)   \# \textasciitilde{}5.57}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blackman}}{blackman}}\label{blackman}

\texttt{window\_blackman(\$n)} (alias \texttt{blackman}) --- generates a
Blackman window of length n. Provides excellent sidelobe suppression at
the cost of main lobe width.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $w = blackman(1024)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blackman\_harris\_window}}{blackman\_harris\_window}}\label{blackman_harris_window}

\texttt{blackman\_harris\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blackman\_harris\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blackman\_harris\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blackman\_w}}{blackman\_w}}\label{blackman_w}

\texttt{blackman\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blackman\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blackman\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blackman\_window}}{blackman\_window}}\label{blackman_window}

\texttt{blackman\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blackman\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blackman\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blackscholes\_call}}{blackscholes\_call}}\label{blackscholes_call}

\texttt{blackscholes\_call} --- batch 20 builtin. Alias for
\texttt{bs\_call}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blackscholes\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blackscholes\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blackscholes\_put}}{blackscholes\_put}}\label{blackscholes_put}

\texttt{blackscholes\_put} --- batch 20 builtin. Alias for
\texttt{bs\_put}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blackscholes\_put $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blackscholes\_put |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blessed}}{blessed}}\label{blessed}

\texttt{blessed} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blessed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blessed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blink}}{blink}}\label{blink}

\texttt{blink} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blink $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blink |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bloch\_purity\_check}}{bloch\_purity\_check}}\label{bloch_purity_check}

\texttt{bloch\_purity\_check} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bloch\_purity\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bloch\_purity\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bloch\_sphere\_x}}{bloch\_sphere\_x}}\label{bloch_sphere_x}

\texttt{bloch\_sphere\_x} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bloch\_sphere\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bloch\_sphere\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bloch\_sphere\_z}}{bloch\_sphere\_z}}\label{bloch_sphere_z}

\texttt{bloch\_sphere\_z} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bloch\_sphere\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bloch\_sphere\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bloch\_to\_density\_real}}{bloch\_to\_density\_real}}\label{bloch_to_density_real}

\texttt{bloch\_to\_density\_real} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bloch\_to\_density\_real $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{block\_devices}}{block\_devices}}\label{block_devices}

\texttt{block\_devices} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = block\_devices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map block\_devices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blossom\_match\_step}}{blossom\_match\_step}}\label{blossom_match_step}

\texttt{blossom\_match\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blossom\_match\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blossom\_match\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blosum45\_score}}{blosum45\_score}}\label{blosum45_score}

\texttt{blosum45\_score} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blosum45\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blosum45\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blue}}{blue}}\label{blue}

\texttt{blue} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{blue\_bold}}{blue\_bold}}\label{blue_bold}

\texttt{blue\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = blue\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map blue\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bm\_horspool}}{bm\_horspool}}\label{bm_horspool}

\texttt{bm\_horspool} --- batch 10 builtin. Alias for
\texttt{horspool\_search}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bm\_horspool $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bm\_horspool |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bmi}}{bmi}}\label{bmi}

\texttt{bmi} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bmi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bmi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bmi\_calc}}{bmi\_calc}}\label{bmi_calc}

\texttt{bmi\_calc} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bmi\_calc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bmi\_calc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bmr\_harris\_benedict\_female}}{bmr\_harris\_benedict\_female}}\label{bmr_harris_benedict_female}

\texttt{bmr\_harris\_benedict\_female} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bmr\_harris\_benedict\_female $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bmr\_harris\_benedict\_female |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bmr\_harris\_benedict\_male}}{bmr\_harris\_benedict\_male}}\label{bmr_harris_benedict_male}

\texttt{bmr\_harris\_benedict\_male} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bmr\_harris\_benedict\_male $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bmr\_harris\_benedict\_male |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bode\_gain\_margin}}{bode\_gain\_margin}}\label{bode_gain_margin}

\texttt{bode\_gain\_margin} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bode\_gain\_margin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bode\_gain\_margin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bode\_phase}}{bode\_phase}}\label{bode_phase}

\texttt{bode\_phase} --- batch 6 builtin. Alias for
\texttt{bode\_phase\_deg}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bode\_phase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bode\_phase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bode\_phase\_margin}}{bode\_phase\_margin}}\label{bode_phase_margin}

\texttt{bode\_phase\_margin} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bode\_phase\_margin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bode\_phase\_margin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{body\_surface\_area\_dubois}}{body\_surface\_area\_dubois}}\label{body_surface_area_dubois}

\texttt{body\_surface\_area\_dubois} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = body\_surface\_area\_dubois $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map body\_surface\_area\_dubois |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{body\_wave\_mb}}{body\_wave\_mb}}\label{body_wave_mb}

\texttt{body\_wave\_mb} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = body\_wave\_mb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map body\_wave\_mb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bogacki\_shampine\_step}}{bogacki\_shampine\_step}}\label{bogacki_shampine_step}

\texttt{bogacki\_shampine\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bogacki\_shampine\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bogacki\_shampine\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bohr\_energy\_ev}}{bohr\_energy\_ev}}\label{bohr_energy_ev}

\texttt{bohr\_energy\_ev} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bohr\_energy\_ev $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bohr\_energy\_ev |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bohr\_magneton}}{bohr\_magneton}}\label{bohr_magneton}

\texttt{bohr\_magneton} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bohr\_magneton $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bohr\_magneton |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bohr\_radius\_n}}{bohr\_radius\_n}}\label{bohr_radius_n}

\texttt{bohr\_radius\_n} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bohr\_radius\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bohr\_radius\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold}}{bold}}\label{bold}

\texttt{bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_blue}}{bold\_blue}}\label{bold_blue}

\texttt{bold\_blue} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_blue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_blue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_cyan}}{bold\_cyan}}\label{bold_cyan}

\texttt{bold\_cyan} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_cyan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_cyan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_green}}{bold\_green}}\label{bold_green}

\texttt{bold\_green} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_green $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_green |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_magenta}}{bold\_magenta}}\label{bold_magenta}

\texttt{bold\_magenta} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_magenta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_magenta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_red}}{bold\_red}}\label{bold_red}

\texttt{bold\_red} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_red $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_red |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_white}}{bold\_white}}\label{bold_white}

\texttt{bold\_white} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bold\_yellow}}{bold\_yellow}}\label{bold_yellow}

\texttt{bold\_yellow} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bold\_yellow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bold\_yellow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boltz}}{boltz}}\label{boltz}

\texttt{boltz} --- constants builtin. Alias for
\texttt{boltzmann\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boltz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boltz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boltzmann}}{boltzmann}}\label{boltzmann}

\texttt{boltzmann} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boltzmann $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boltzmann |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boltzmann\_const}}{boltzmann\_const}}\label{boltzmann_const}

\texttt{boltzmann\_const} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boltzmann\_const $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boltzmann\_const |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boltzmann\_constant}}{boltzmann\_constant}}\label{boltzmann_constant}

\texttt{boltzmann\_constant} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boltzmann\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boltzmann\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boltzmann\_softmax\_action}}{boltzmann\_softmax\_action}}\label{boltzmann_softmax_action}

\texttt{boltzmann\_softmax\_action} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boltzmann\_softmax\_action $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boltzmann\_softmax\_action |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bond\_duration}}{bond\_duration}}\label{bond_duration}

\texttt{duration(\$face,\ \$coupon\_rate,\ \$ytm,\ \$periods)} (alias
\texttt{bond\_duration}) --- computes the Macaulay duration of a bond,
measuring interest rate sensitivity as weighted average time to receive
cash flows.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p duration(1000, 0.05, 0.05, 10)   \# \textasciitilde{}7.7 years}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bond\_price}}{bond\_price}}\label{bond_price}

\texttt{bond\_price(\$face,\ \$coupon\_rate,\ \$ytm,\ \$periods)} ---
computes the present value (price) of a bond given face value, coupon
rate, yield to maturity, and number of periods.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bond\_price(1000, 0.05, 0.04, 10)   \# \textasciitilde{}1081 (premium)}
\NormalTok{p bond\_price(1000, 0.05, 0.06, 10)   \# \textasciitilde{}926 (discount)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bond\_yield}}{bond\_yield}}\label{bond_yield}

\texttt{bond\_yield(\$price,\ \$face,\ \$coupon\_rate,\ \$periods)} ---
computes the yield to maturity of a bond given its current price. Uses
Newton-Raphson iteration.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bond\_yield(950, 1000, 0.05, 10)   \# \textasciitilde{}5.7\%}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bondi\_mass\_step}}{bondi\_mass\_step}}\label{bondi_mass_step}

\texttt{bondi\_mass\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bondi\_mass\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bondi\_mass\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bondprc}}{bondprc}}\label{bondprc}

\texttt{bondprc} --- finance (extended) builtin. Alias for
\texttt{bond\_price}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bondprc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bondprc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bondyld}}{bondyld}}\label{bondyld}

\texttt{bondyld} --- finance (extended) builtin. Alias for
\texttt{bond\_yield}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bondyld $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bondyld |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bool\_each}}{bool\_each}}\label{bool_each}

\texttt{bool\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bool\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bool\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bool\_to\_int}}{bool\_to\_int}}\label{bool_to_int}

\texttt{bool\_to\_int} --- boolean combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bool\_to\_int $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boole\_int}}{boole\_int}}\label{boole_int}

\texttt{boole\_int} --- batch 19 builtin. Alias for
\texttt{boole\_rule}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boole\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boole\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boole\_rule}}{boole\_rule}}\label{boole_rule}

\texttt{boole\_rule} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boole\_rule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boole\_rule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bootstrap\_se\_estimate}}{bootstrap\_se\_estimate}}\label{bootstrap_se_estimate}

\texttt{bootstrap\_se\_estimate} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bootstrap\_se\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bootstrap\_se\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{borda\_count\_step}}{borda\_count\_step}}\label{borda_count_step}

\texttt{borda\_count\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = borda\_count\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map borda\_count\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{borders\_of\_string}}{borders\_of\_string}}\label{borders_of_string}

\texttt{borders\_of\_string} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = borders\_of\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map borders\_of\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bornhuetter\_ferguson}}{bornhuetter\_ferguson}}\label{bornhuetter_ferguson}

\texttt{bornhuetter\_ferguson} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bornhuetter\_ferguson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bornhuetter\_ferguson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boruvka\_step}}{boruvka\_step}}\label{boruvka_step}

\texttt{boruvka\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boruvka\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boruvka\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bose\_einstein\_g}}{bose\_einstein\_g}}\label{bose_einstein_g}

\texttt{bose\_einstein\_g} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bose\_einstein\_g $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bose\_einstein\_g |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bose\_einstein\_pmf}}{bose\_einstein\_pmf}}\label{bose_einstein_pmf}

\texttt{bose\_einstein\_pmf} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bose\_einstein\_pmf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bose\_einstein\_pmf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boston\_mechanism\_step}}{boston\_mechanism\_step}}\label{boston_mechanism_step}

\texttt{boston\_mechanism\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boston\_mechanism\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boston\_mechanism\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{both}}{both}}\label{both}

\texttt{both} --- boolean combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = both $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map both |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bowley\_skewness}}{bowley\_skewness}}\label{bowley_skewness}

\texttt{bowley\_skewness} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bowley\_skewness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bowley\_skewness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{box\_blur\_kernel}}{box\_blur\_kernel}}\label{box_blur_kernel}

\texttt{box\_blur\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = box\_blur\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map box\_blur\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{box\_pierce\_test}}{box\_pierce\_test}}\label{box_pierce_test}

\texttt{box\_pierce\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = box\_pierce\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map box\_pierce\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boyer\_lindquist\_step}}{boyer\_lindquist\_step}}\label{boyer_lindquist_step}

\texttt{boyer\_lindquist\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boyer\_lindquist\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boyer\_lindquist\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{boykov\_kolmogorov\_step}}{boykov\_kolmogorov\_step}}\label{boykov_kolmogorov_step}

\texttt{boykov\_kolmogorov\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = boykov\_kolmogorov\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map boykov\_kolmogorov\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bp\_elevation}}{bp\_elevation}}\label{bp_elevation}

\texttt{bp\_elevation} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bp\_elevation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bp\_elevation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bpm\_to\_midi\_tick\_us}}{bpm\_to\_midi\_tick\_us}}\label{bpm_to_midi_tick_us}

\texttt{bpm\_to\_midi\_tick\_us} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bpm\_to\_midi\_tick\_us $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bpm\_to\_period}}{bpm\_to\_period}}\label{bpm_to_period}

\texttt{bpm\_to\_period} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bpm\_to\_period $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bpm\_to\_spb}}{bpm\_to\_spb}}\label{bpm_to_spb}

\texttt{bpm\_to\_spb} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bpm\_to\_spb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bracelet\_count}}{bracelet\_count}}\label{bracelet_count}

\texttt{bracelet\_count} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bracelet\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bracelet\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bracket}}{bracket}}\label{bracket}

\texttt{bracket} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bracket $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bracket |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{braille}}{braille}}\label{braille}

\texttt{braille} --- encoding / phonetics builtin. Alias for
\texttt{braille\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = braille $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map braille |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{braille\_encode}}{braille\_encode}}\label{braille_encode}

\texttt{braille\_encode} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = braille\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map braille\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{branch\_and\_bound\_step}}{branch\_and\_bound\_step}}\label{branch_and_bound_step}

\texttt{branch\_and\_bound\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = branch\_and\_bound\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map branch\_and\_bound\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{branch\_length\_substitutions}}{branch\_length\_substitutions}}\label{branch_length_substitutions}

\texttt{branch\_length\_substitutions} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = branch\_length\_substitutions $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map branch\_length\_substitutions |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brans\_dicke\_step}}{brans\_dicke\_step}}\label{brans_dicke_step}

\texttt{brans\_dicke\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brans\_dicke\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brans\_dicke\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brayton\_efficiency}}{brayton\_efficiency}}\label{brayton_efficiency}

\texttt{brayton\_efficiency} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brayton\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brayton\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{break\_even}}{break\_even}}\label{break_even}

\texttt{break\_even} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = break\_even $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map break\_even |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{break\_fn}}{break\_fn}}\label{break_fn}

\texttt{break\_fn} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = break\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map break\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{breakeven}}{breakeven}}\label{breakeven}

\texttt{breakeven} --- finance builtin. Alias for \texttt{break\_even}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = breakeven $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map breakeven |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brent}}{brent}}\label{brent}

\texttt{brent} --- batch 19 builtin. Alias for \texttt{brent\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brent\_root}}{brent\_root}}\label{brent_root}

\texttt{brent\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brent\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brent\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{breusch\_godfrey}}{breusch\_godfrey}}\label{breusch_godfrey}

\texttt{breusch\_godfrey} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = breusch\_godfrey $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map breusch\_godfrey |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{breusch\_godfrey\_test}}{breusch\_godfrey\_test}}\label{breusch_godfrey_test}

\texttt{breusch\_godfrey\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = breusch\_godfrey\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map breusch\_godfrey\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{breusch\_pagan\_lm}}{breusch\_pagan\_lm}}\label{breusch_pagan_lm}

\texttt{breusch\_pagan\_lm} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = breusch\_pagan\_lm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map breusch\_pagan\_lm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{breusch\_pagan\_test}}{breusch\_pagan\_test}}\label{breusch_pagan_test}

\texttt{breusch\_pagan\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = breusch\_pagan\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map breusch\_pagan\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brewster}}{brewster}}\label{brewster}

\texttt{brewster} --- physics formulas builtin. Alias for
\texttt{brewster\_angle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brewster $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brewster |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brewster\_angle}}{brewster\_angle}}\label{brewster_angle}

\texttt{brewster\_angle} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brewster\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brewster\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bridge\_edge}}{bridge\_edge}}\label{bridge_edge}

\texttt{bridge\_edge} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bridge\_edge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bridge\_edge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bridges}}{bridges}}\label{bridges}

\texttt{bridges} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bridges $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bridges |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bridges\_edges}}{bridges\_edges}}\label{bridges_edges}

\texttt{bridges\_edges} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bridges\_edges $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bridges\_edges |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brier\_score}}{brier\_score}}\label{brier_score}

\texttt{brier\_score} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brier\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brier\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_blue}}{bright\_blue}}\label{bright_blue}

\texttt{bright\_blue} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_blue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_blue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_cyan}}{bright\_cyan}}\label{bright_cyan}

\texttt{bright\_cyan} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_cyan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_cyan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_green}}{bright\_green}}\label{bright_green}

\texttt{bright\_green} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_green $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_green |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_magenta}}{bright\_magenta}}\label{bright_magenta}

\texttt{bright\_magenta} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_magenta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_magenta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_red}}{bright\_red}}\label{bright_red}

\texttt{bright\_red} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_red $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_red |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_white}}{bright\_white}}\label{bright_white}

\texttt{bright\_white} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bright\_yellow}}{bright\_yellow}}\label{bright_yellow}

\texttt{bright\_yellow} --- color / ansi builtin. Alias for
\texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bright\_yellow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bright\_yellow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brkf}}{brkf}}\label{brkf}

\texttt{brkf} --- haskell list functions builtin. Alias for
\texttt{break\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brkf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brkf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bron\_kerbosch}}{bron\_kerbosch}}\label{bron_kerbosch}

\texttt{bron\_kerbosch} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bron\_kerbosch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bron\_kerbosch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brotli\_distance\_code\_count}}{brotli\_distance\_code\_count}}\label{brotli_distance_code_count}

\texttt{brotli\_distance\_code\_count} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brotli\_distance\_code\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brotli\_distance\_code\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brotli\_encode\_meta}}{brotli\_encode\_meta}}\label{brotli_encode_meta}

\texttt{brotli\_encode\_meta} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brotli\_encode\_meta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brotli\_encode\_meta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brotli\_huffman\_table}}{brotli\_huffman\_table}}\label{brotli_huffman_table}

\texttt{brotli\_huffman\_table} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brotli\_huffman\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brotli\_huffman\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brotli\_meta\_block}}{brotli\_meta\_block}}\label{brotli_meta_block}

\texttt{brotli\_meta\_block} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brotli\_meta\_block $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brotli\_meta\_block |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brown\_york\_quasilocal}}{brown\_york\_quasilocal}}\label{brown_york_quasilocal}

\texttt{brown\_york\_quasilocal} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brown\_york\_quasilocal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brown\_york\_quasilocal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brunt\_vaisala\_full}}{brunt\_vaisala\_full}}\label{brunt_vaisala_full}

\texttt{brunt\_vaisala\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brunt\_vaisala\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brunt\_vaisala\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{brzozowski\_derivative}}{brzozowski\_derivative}}\label{brzozowski_derivative}

\texttt{brzozowski\_derivative} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = brzozowski\_derivative $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map brzozowski\_derivative |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_call}}{bs\_call}}\label{bs_call}

\texttt{bs\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bs\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bs\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_delta}}{bs\_delta}}\label{bs_delta}

\texttt{bs\_delta} (aliases \texttt{bsdelta}, \texttt{option\_delta})
computes the Black-Scholes delta (∂C/∂S). Args: S, K, T, r, sigma.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bsdelta(100, 100, 1, 0.05, 0.2)  \# ≈ 0.64}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_gamma}}{bs\_gamma}}\label{bs_gamma}

\texttt{bs\_gamma} computes the Black-Scholes gamma (∂²C/∂S²). Measures
convexity of option value.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bsgamma(100, 100, 1, 0.05, 0.2)  \# ≈ 0.019}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_put}}{bs\_put}}\label{bs_put}

\texttt{bs\_put} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bs\_put $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bs\_put |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_rho}}{bs\_rho}}\label{bs_rho}

\texttt{bs\_rho} computes the Black-Scholes rho (∂C/∂r). Sensitivity to
interest rate.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bsrho(100, 100, 1, 0.05, 0.2)  \# ≈ 46}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_rho\_call}}{bs\_rho\_call}}\label{bs_rho_call}

\texttt{bs\_rho\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bs\_rho\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bs\_rho\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_theta}}{bs\_theta}}\label{bs_theta}

\texttt{bs\_theta} computes the Black-Scholes theta (∂C/∂t). Time decay
per unit time.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bstheta(100, 100, 1, 0.05, 0.2)  \# negative (time decay)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_theta\_call}}{bs\_theta\_call}}\label{bs_theta_call}

\texttt{bs\_theta\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bs\_theta\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bs\_theta\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bs\_vega}}{bs\_vega}}\label{bs_vega}

\texttt{bs\_vega} computes the Black-Scholes vega (∂C/∂σ). Sensitivity
to volatility.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p bsvega(100, 100, 1, 0.05, 0.2)  \# ≈ 37.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bsa\_dubois}}{bsa\_dubois}}\label{bsa_dubois}

\texttt{bsa\_dubois} --- batch 12 builtin. Alias for
\texttt{body\_surface\_area\_dubois}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bsa\_dubois $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bsa\_dubois |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bsearch}}{bsearch}}\label{bsearch}

\texttt{bsearch} --- collection (batch 2) builtin. Alias for
\texttt{binary\_search}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bsearch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bsearch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bsgs\_discrete\_log}}{bsgs\_discrete\_log}}\label{bsgs_discrete_log}

\texttt{bsgs\_discrete\_log} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bsgs\_discrete\_log $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bsgs\_discrete\_log |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bsize}}{bsize}}\label{bsize}

\texttt{bsize} --- misc / utility builtin. Alias for
\texttt{byte\_size}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bsize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bsize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{btc\_addr\_check}}{btc\_addr\_check}}\label{btc_addr_check}

\texttt{btc\_addr\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = btc\_addr\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map btc\_addr\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{btch}}{btch}}\label{btch}

\texttt{btch} --- additional missing stdlib functions builtin. Alias for
\texttt{batched}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = btch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map btch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{btrim}}{btrim}}\label{btrim}

\texttt{btrim} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = btrim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map btrim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{btu\_to\_joules}}{btu\_to\_joules}}\label{btu_to_joules}

\texttt{btu\_to\_joules} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = btu\_to\_joules $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bucket}}{bucket}}\label{bucket}

\texttt{bucket} --- matrix operations (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bucket $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bucket |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{buffer\_capacity\_acid\_base}}{buffer\_capacity\_acid\_base}}\label{buffer_capacity_acid_base}

\texttt{buffer\_capacity\_acid\_base} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = buffer\_capacity\_acid\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map buffer\_capacity\_acid\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bulirsch\_stoer\_step}}{bulirsch\_stoer\_step}}\label{bulirsch_stoer_step}

\texttt{bulirsch\_stoer\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bulirsch\_stoer\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bulirsch\_stoer\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{burr\_xii\_cdf}}{burr\_xii\_cdf}}\label{burr_xii_cdf}

\texttt{burr\_xii\_cdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = burr\_xii\_cdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map burr\_xii\_cdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{burr\_xii\_pdf}}{burr\_xii\_pdf}}\label{burr_xii_pdf}

\texttt{burr\_xii\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = burr\_xii\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map burr\_xii\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{business\_days\_between}}{business\_days\_between}}\label{business_days_between}

\texttt{business\_days\_between} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = business\_days\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map business\_days\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{butlast}}{butlast}}\label{butlast}

\texttt{butlast} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = butlast $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map butlast |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{butler\_volmer\_current}}{butler\_volmer\_current}}\label{butler_volmer_current}

\texttt{butler\_volmer\_current} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = butler\_volmer\_current $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map butler\_volmer\_current |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{butter\_hp\_mag}}{butter\_hp\_mag}}\label{butter_hp_mag}

\texttt{butter\_hp\_mag} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = butter\_hp\_mag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map butter\_hp\_mag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{butter\_lp\_re}}{butter\_lp\_re}}\label{butter_lp_re}

\texttt{butter\_lp\_re} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = butter\_lp\_re $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map butter\_lp\_re |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{butterworth\_order}}{butterworth\_order}}\label{butterworth_order}

\texttt{butterworth\_order} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = butterworth\_order $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map butterworth\_order |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{butterworth\_prewarp}}{butterworth\_prewarp}}\label{butterworth_prewarp}

\texttt{butterworth\_prewarp} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = butterworth\_prewarp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map butterworth\_prewarp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bwt\_decode}}{bwt\_decode}}\label{bwt_decode}

\texttt{bwt\_decode} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bwt\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bwt\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bwt\_encode}}{bwt\_encode}}\label{bwt_encode}

\texttt{bwt\_encode} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bwt\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bwt\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{byte\_length}}{byte\_length}}\label{byte_length}

\texttt{byte\_length} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = byte\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map byte\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{byte\_size}}{byte\_size}}\label{byte_size}

\texttt{byte\_size} --- misc / utility builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = byte\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map byte\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bytecode\_disasm\_step}}{bytecode\_disasm\_step}}\label{bytecode_disasm_step}

\texttt{bytecode\_disasm\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bytecode\_disasm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bytecode\_disasm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bytes\_to\_bits}}{bytes\_to\_bits}}\label{bytes_to_bits}

\texttt{bytes\_to\_bits} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bytes\_to\_bits $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bytes\_to\_gb}}{bytes\_to\_gb}}\label{bytes_to_gb}

\texttt{bytes\_to\_gb} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bytes\_to\_gb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bytes\_to\_hex\_str}}{bytes\_to\_hex\_str}}\label{bytes_to_hex_str}

\texttt{bytes\_to\_hex\_str} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bytes\_to\_hex\_str $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bytes\_to\_kb}}{bytes\_to\_kb}}\label{bytes_to_kb}

\texttt{bytes\_to\_kb} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bytes\_to\_kb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bytes\_to\_mb}}{bytes\_to\_mb}}\label{bytes_to_mb}

\texttt{bytes\_to\_mb} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bytes\_to\_mb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{bz2\_encode\_step}}{bz2\_encode\_step}}\label{bz2_encode_step}

\texttt{bz2\_encode\_step} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = bz2\_encode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map bz2\_encode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{c256}}{c256}}\label{c256}

\texttt{c256} --- color / ansi builtin. Alias for \texttt{color256}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = c256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map c256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{c2s}}{c2s}}\label{c2s}

\texttt{c2s} --- string processing (uncategorized batch) builtin. Alias
for \texttt{camel\_to\_snake}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = c2s $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map c2s |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{c\_parallel}}{c\_parallel}}\label{c_parallel}

\texttt{c\_parallel} --- batch 12 builtin. Alias for
\texttt{capacitance\_parallel}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = c\_parallel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map c\_parallel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{c\_series}}{c\_series}}\label{c_series}

\texttt{c\_series} --- batch 12 builtin. Alias for
\texttt{capacitance\_series}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = c\_series $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map c\_series |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{c\_to\_f}}{c\_to\_f}}\label{c_to_f}

\texttt{c\_to\_f} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = c\_to\_f $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{c\_to\_k}}{c\_to\_k}}\label{c_to_k}

\texttt{c\_to\_k} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = c\_to\_k $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cabling\_pair\_signature}}{cabling\_pair\_signature}}\label{cabling_pair_signature}

\texttt{cabling\_pair\_signature} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cabling\_pair\_signature $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cabling\_pair\_signature |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cache\_clear}}{cache\_clear}}\label{cache_clear}

\texttt{cache\_clear} --- caching builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cache\_clear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cache\_clear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cache\_control\_parse}}{cache\_control\_parse}}\label{cache_control_parse}

\texttt{cache\_control\_parse} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cache\_control\_parse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cache\_control\_parse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cache\_exists}}{cache\_exists}}\label{cache_exists}

\texttt{cache\_exists} --- caching builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cache\_exists $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cache\_exists |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cache\_stats}}{cache\_stats}}\label{cache_stats}

\texttt{cache\_stats} --- caching builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cache\_stats $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cache\_stats |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cacheview}}{cacheview}}\label{cacheview}

\texttt{cacheview} --- caching builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cacheview $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cacheview |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{caesar\_shift}}{caesar\_shift}}\label{caesar_shift}

\texttt{caesar\_shift} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = caesar\_shift $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map caesar\_shift |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cagr}}{cagr}}\label{cagr}

\texttt{cagr} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cagr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cagr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cake\_number}}{cake\_number}}\label{cake_number}

\texttt{cake\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cake\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cake\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cal\_to\_joules}}{cal\_to\_joules}}\label{cal_to_joules}

\texttt{cal\_to\_joules} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cal\_to\_joules $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{calmar\_ratio}}{calmar\_ratio}}\label{calmar_ratio}

\texttt{calmar\_ratio} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = calmar\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map calmar\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{calorimeter\_dt}}{calorimeter\_dt}}\label{calorimeter_dt}

\texttt{calorimeter\_dt} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = calorimeter\_dt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map calorimeter\_dt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{calorimetric\_heat\_battery}}{calorimetric\_heat\_battery}}\label{calorimetric_heat_battery}

\texttt{calorimetric\_heat\_battery} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = calorimetric\_heat\_battery $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map calorimetric\_heat\_battery |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{camel\_to\_snake}}{camel\_to\_snake}}\label{camel_to_snake}

\texttt{camel\_to\_snake} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = camel\_to\_snake $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{camel\_words}}{camel\_words}}\label{camel_words}

\texttt{camel\_words} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = camel\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map camel\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{canny\_threshold\_step}}{canny\_threshold\_step}}\label{canny_threshold_step}

\texttt{canny\_threshold\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = canny\_threshold\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map canny\_threshold\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cap}}{cap}}\label{cap}

\texttt{cap} --- trivial string ops builtin. Alias for
\texttt{capitalize}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capacitance}}{capacitance}}\label{capacitance}

\texttt{capacitance} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capacitance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capacitance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capacitance\_parallel}}{capacitance\_parallel}}\label{capacitance_parallel}

\texttt{capacitance\_parallel} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capacitance\_parallel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capacitance\_parallel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capacitance\_parallel\_sum}}{capacitance\_parallel\_sum}}\label{capacitance_parallel_sum}

\texttt{capacitance\_parallel\_sum} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capacitance\_parallel\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capacitance\_parallel\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capacitance\_series}}{capacitance\_series}}\label{capacitance_series}

\texttt{capacitance\_series} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capacitance\_series $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capacitance\_series |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capacitor\_charge}}{capacitor\_charge}}\label{capacitor_charge}

\texttt{capacitor\_charge} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capacitor\_charge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capacitor\_charge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capacitor\_energy}}{capacitor\_energy}}\label{capacitor_energy}

\texttt{capacitor\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capacitor\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capacitor\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capenergy}}{capenergy}}\label{capenergy}

\texttt{capenergy} --- physics formulas builtin. Alias for
\texttt{capacitor\_energy}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capenergy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capenergy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capg}}{capg}}\label{capg}

\texttt{capg} --- extended stdlib builtin. Alias for
\texttt{capture\_groups}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capitalize}}{capitalize}}\label{capitalize}

\texttt{capitalize} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capitalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capitalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capitalize\_words}}{capitalize\_words}}\label{capitalize_words}

\texttt{capitalize\_words} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capitalize\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capitalize\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capm}}{capm}}\label{capm}

\texttt{capm(\$risk\_free,\ \$beta,\ \$market\_return)} --- computes
expected return using the Capital Asset Pricing Model: rf + β(rm - rf).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p capm(0.02, 1.2, 0.08)   \# 9.2\% expected return}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capm\_expected\_return}}{capm\_expected\_return}}\label{capm_expected_return}

\texttt{capm\_expected\_return} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capm\_expected\_return $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capm\_expected\_return |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{capture\_groups}}{capture\_groups}}\label{capture_groups}

\texttt{capture\_groups} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = capture\_groups $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map capture\_groups |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{carmichael\_q}}{carmichael\_q}}\label{carmichael_q}

\texttt{carmichael\_q} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = carmichael\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map carmichael\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{carnot\_efficiency}}{carnot\_efficiency}}\label{carnot_efficiency}

\texttt{carnot\_efficiency} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = carnot\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map carnot\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{carrying\_capacity\_from\_data}}{carrying\_capacity\_from\_data}}\label{carrying_capacity_from_data}

\texttt{carrying\_capacity\_from\_data} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = carrying\_capacity\_from\_data $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map carrying\_capacity\_from\_data |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cart\_n}}{cart\_n}}\label{cart_n}

\texttt{cart\_n} --- batch 10 builtin. Alias for
\texttt{cartesian\_product\_n}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cart\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cart\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cartan\_determinant\_a2}}{cartan\_determinant\_a2}}\label{cartan_determinant_a2}

\texttt{cartan\_determinant\_a2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cartan\_determinant\_a2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cartan\_determinant\_a2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cartan\_matrix\_b2}}{cartan\_matrix\_b2}}\label{cartan_matrix_b2}

\texttt{cartan\_matrix\_b2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cartan\_matrix\_b2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cartan\_matrix\_b2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cartesian\_power}}{cartesian\_power}}\label{cartesian_power}

\texttt{cartesian\_power} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cartesian\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cartesian\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cartesian\_product}}{cartesian\_product}}\label{cartesian_product}

\texttt{cartesian\_product} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cartesian\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cartesian\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cartesian\_product\_n}}{cartesian\_product\_n}}\label{cartesian_product_n}

\texttt{cartesian\_product\_n} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cartesian\_product\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cartesian\_product\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cartpow}}{cartpow}}\label{cartpow}

\texttt{cartpow} --- extended stdlib batch 3 builtin. Alias for
\texttt{cartesian\_power}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cartpow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cartpow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_admm\_lasso\_step}}{cas\_admm\_lasso\_step}}\label{cas_admm_lasso_step}

\texttt{cas\_admm\_lasso\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_admm\_lasso\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_admm\_lasso\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_alternating\_projection}}{cas\_alternating\_projection}}\label{cas_alternating_projection}

\texttt{cas\_alternating\_projection} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_alternating\_projection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_alternating\_projection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_arnoldi\_iteration\_step}}{cas\_arnoldi\_iteration\_step}}\label{cas_arnoldi_iteration_step}

\texttt{cas\_arnoldi\_iteration\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_arnoldi\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_arnoldi\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_basis\_pursuit\_step}}{cas\_basis\_pursuit\_step}}\label{cas_basis_pursuit_step}

\texttt{cas\_basis\_pursuit\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_basis\_pursuit\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_basis\_pursuit\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_block\_lu\_step}}{cas\_block\_lu\_step}}\label{cas_block_lu_step}

\texttt{cas\_block\_lu\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_block\_lu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_block\_lu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_buchberger\_step}}{cas\_buchberger\_step}}\label{cas_buchberger_step}

\texttt{cas\_buchberger\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_buchberger\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_buchberger\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_bunch\_kaufman\_step}}{cas\_bunch\_kaufman\_step}}\label{cas_bunch_kaufman_step}

\texttt{cas\_bunch\_kaufman\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_bunch\_kaufman\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_bunch\_kaufman\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_burnside\_count\_step}}{cas\_burnside\_count\_step}}\label{cas_burnside_count_step}

\texttt{cas\_burnside\_count\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_burnside\_count\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_burnside\_count\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_chebyshev\_eval}}{cas\_chebyshev\_eval}}\label{cas_chebyshev_eval}

\texttt{cas\_chebyshev\_eval} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_chebyshev\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_chebyshev\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_cholesky\_step}}{cas\_cholesky\_step}}\label{cas_cholesky_step}

\texttt{cas\_cholesky\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_cholesky\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_cholesky\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_classical\_gram\_schmidt}}{cas\_classical\_gram\_schmidt}}\label{cas_classical_gram_schmidt}

\texttt{cas\_classical\_gram\_schmidt} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_classical\_gram\_schmidt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_classical\_gram\_schmidt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_companion\_matrix\_root}}{cas\_companion\_matrix\_root}}\label{cas_companion_matrix_root}

\texttt{cas\_companion\_matrix\_root} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_companion\_matrix\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_companion\_matrix\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_constrained\_ls\_step}}{cas\_constrained\_ls\_step}}\label{cas_constrained_ls_step}

\texttt{cas\_constrained\_ls\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_constrained\_ls\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_constrained\_ls\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_continued\_fraction\_step}}{cas\_continued\_fraction\_step}}\label{cas_continued_fraction_step}

\texttt{cas\_continued\_fraction\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_continued\_fraction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_continued\_fraction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_cosamp\_step}}{cas\_cosamp\_step}}\label{cas_cosamp_step}

\texttt{cas\_cosamp\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_cosamp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_cosamp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_descartes\_rule\_count}}{cas\_descartes\_rule\_count}}\label{cas_descartes_rule_count}

\texttt{cas\_descartes\_rule\_count} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_descartes\_rule\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_descartes\_rule\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_drazin\_inverse\_step}}{cas\_drazin\_inverse\_step}}\label{cas_drazin_inverse_step}

\texttt{cas\_drazin\_inverse\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_drazin\_inverse\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_drazin\_inverse\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_dykstra\_step}}{cas\_dykstra\_step}}\label{cas_dykstra_step}

\texttt{cas\_dykstra\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_dykstra\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_dykstra\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_eigenvalue\_inverse\_iteration}}{cas\_eigenvalue\_inverse\_iteration}}\label{cas_eigenvalue_inverse_iteration}

\texttt{cas\_eigenvalue\_inverse\_iteration} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_eigenvalue\_inverse\_iteration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_eigenvalue\_inverse\_iteration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_elastic\_net\_step}}{cas\_elastic\_net\_step}}\label{cas_elastic_net_step}

\texttt{cas\_elastic\_net\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_elastic\_net\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_elastic\_net\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_expand\_two\_terms}}{cas\_expand\_two\_terms}}\label{cas_expand_two_terms}

\texttt{cas\_expand\_two\_terms} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_expand\_two\_terms $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_expand\_two\_terms |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_extended\_euclid\_step}}{cas\_extended\_euclid\_step}}\label{cas_extended_euclid_step}

\texttt{cas\_extended\_euclid\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_extended\_euclid\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_extended\_euclid\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_factor\_quadratic}}{cas\_factor\_quadratic}}\label{cas_factor_quadratic}

\texttt{cas\_factor\_quadratic} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_factor\_quadratic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_factor\_quadratic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_gcd\_polynomial\_step}}{cas\_gcd\_polynomial\_step}}\label{cas_gcd_polynomial_step}

\texttt{cas\_gcd\_polynomial\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_gcd\_polynomial\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_gcd\_polynomial\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_gegenbauer\_eval}}{cas\_gegenbauer\_eval}}\label{cas_gegenbauer_eval}

\texttt{cas\_gegenbauer\_eval} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_gegenbauer\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_gegenbauer\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_generalized\_eigen}}{cas\_generalized\_eigen}}\label{cas_generalized_eigen}

\texttt{cas\_generalized\_eigen} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_generalized\_eigen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_generalized\_eigen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_givens\_rotation\_apply}}{cas\_givens\_rotation\_apply}}\label{cas_givens_rotation_apply}

\texttt{cas\_givens\_rotation\_apply} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_givens\_rotation\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_givens\_rotation\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_groebner\_lt\_step}}{cas\_groebner\_lt\_step}}\label{cas_groebner_lt_step}

\texttt{cas\_groebner\_lt\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_groebner\_lt\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_groebner\_lt\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_hermite\_eval}}{cas\_hermite\_eval}}\label{cas_hermite_eval}

\texttt{cas\_hermite\_eval} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_hermite\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_hermite\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_hermite\_normal\_step}}{cas\_hermite\_normal\_step}}\label{cas_hermite_normal_step}

\texttt{cas\_hermite\_normal\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_hermite\_normal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_hermite\_normal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_householder\_reflection}}{cas\_householder\_reflection}}\label{cas_householder_reflection}

\texttt{cas\_householder\_reflection} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_householder\_reflection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_householder\_reflection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_iht\_iteration}}{cas\_iht\_iteration}}\label{cas_iht_iteration}

\texttt{cas\_iht\_iteration} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_iht\_iteration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_iht\_iteration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_indicator\_simplex\_proj}}{cas\_indicator\_simplex\_proj}}\label{cas_indicator_simplex_proj}

\texttt{cas\_indicator\_simplex\_proj} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_indicator\_simplex\_proj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_indicator\_simplex\_proj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_jacobi\_eigen\_step}}{cas\_jacobi\_eigen\_step}}\label{cas_jacobi_eigen_step}

\texttt{cas\_jacobi\_eigen\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_jacobi\_eigen\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_jacobi\_eigen\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_jacobi\_eval}}{cas\_jacobi\_eval}}\label{cas_jacobi_eval}

\texttt{cas\_jacobi\_eval} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_jacobi\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_jacobi\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_kronecker\_product\_step}}{cas\_kronecker\_product\_step}}\label{cas_kronecker_product_step}

\texttt{cas\_kronecker\_product\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_kronecker\_product\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_kronecker\_product\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_lagrange\_interpolate}}{cas\_lagrange\_interpolate}}\label{cas_lagrange_interpolate}

\texttt{cas\_lagrange\_interpolate} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_lagrange\_interpolate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_lagrange\_interpolate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_laguerre\_eval}}{cas\_laguerre\_eval}}\label{cas_laguerre_eval}

\texttt{cas\_laguerre\_eval} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_laguerre\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_laguerre\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_lanczos\_iteration\_step}}{cas\_lanczos\_iteration\_step}}\label{cas_lanczos_iteration_step}

\texttt{cas\_lanczos\_iteration\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_lanczos\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_lanczos\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_lasso\_soft\_threshold}}{cas\_lasso\_soft\_threshold}}\label{cas_lasso_soft_threshold}

\texttt{cas\_lasso\_soft\_threshold} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_lasso\_soft\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_lasso\_soft\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_ldlt\_step}}{cas\_ldlt\_step}}\label{cas_ldlt_step}

\texttt{cas\_ldlt\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_ldlt\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_ldlt\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_least\_squares\_solve}}{cas\_least\_squares\_solve}}\label{cas_least_squares_solve}

\texttt{cas\_least\_squares\_solve} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_least\_squares\_solve $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_least\_squares\_solve |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_legendre\_eval}}{cas\_legendre\_eval}}\label{cas_legendre_eval}

\texttt{cas\_legendre\_eval} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_legendre\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_legendre\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_lyapunov\_continuous\_step}}{cas\_lyapunov\_continuous\_step}}\label{cas_lyapunov_continuous_step}

\texttt{cas\_lyapunov\_continuous\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_lyapunov\_continuous\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_lyapunov\_continuous\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_lyapunov\_discrete\_step}}{cas\_lyapunov\_discrete\_step}}\label{cas_lyapunov_discrete_step}

\texttt{cas\_lyapunov\_discrete\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_lyapunov\_discrete\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_lyapunov\_discrete\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_macaulay\_matrix\_step}}{cas\_macaulay\_matrix\_step}}\label{cas_macaulay_matrix_step}

\texttt{cas\_macaulay\_matrix\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_macaulay\_matrix\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_macaulay\_matrix\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_matrix\_exp\_pade}}{cas\_matrix\_exp\_pade}}\label{cas_matrix_exp_pade}

\texttt{cas\_matrix\_exp\_pade} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_matrix\_exp\_pade $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_matrix\_exp\_pade |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_matrix\_function\_step}}{cas\_matrix\_function\_step}}\label{cas_matrix_function_step}

\texttt{cas\_matrix\_function\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_matrix\_function\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_matrix\_function\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_matrix\_log\_step}}{cas\_matrix\_log\_step}}\label{cas_matrix_log_step}

\texttt{cas\_matrix\_log\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_matrix\_log\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_matrix\_log\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_matrix\_pencil\_step}}{cas\_matrix\_pencil\_step}}\label{cas_matrix_pencil_step}

\texttt{cas\_matrix\_pencil\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_matrix\_pencil\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_matrix\_pencil\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_matrix\_sqrt\_step}}{cas\_matrix\_sqrt\_step}}\label{cas_matrix_sqrt_step}

\texttt{cas\_matrix\_sqrt\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_matrix\_sqrt\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_matrix\_sqrt\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_minimal\_polynomial}}{cas\_minimal\_polynomial}}\label{cas_minimal_polynomial}

\texttt{cas\_minimal\_polynomial} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_minimal\_polynomial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_minimal\_polynomial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_modified\_cholesky}}{cas\_modified\_cholesky}}\label{cas_modified_cholesky}

\texttt{cas\_modified\_cholesky} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_modified\_cholesky $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_modified\_cholesky |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_modified\_gram\_schmidt}}{cas\_modified\_gram\_schmidt}}\label{cas_modified_gram_schmidt}

\texttt{cas\_modified\_gram\_schmidt} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_modified\_gram\_schmidt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_modified\_gram\_schmidt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_modular\_inverse}}{cas\_modular\_inverse}}\label{cas_modular_inverse}

\texttt{cas\_modular\_inverse} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_modular\_inverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_modular\_inverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_moore\_penrose\_step}}{cas\_moore\_penrose\_step}}\label{cas_moore_penrose_step}

\texttt{cas\_moore\_penrose\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_moore\_penrose\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_moore\_penrose\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_omp\_step}}{cas\_omp\_step}}\label{cas_omp_step}

\texttt{cas\_omp\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_omp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_omp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_partial\_fraction\_simple}}{cas\_partial\_fraction\_simple}}\label{cas_partial_fraction_simple}

\texttt{cas\_partial\_fraction\_simple} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_partial\_fraction\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_partial\_fraction\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_pivoted\_lu\_step}}{cas\_pivoted\_lu\_step}}\label{cas_pivoted_lu_step}

\texttt{cas\_pivoted\_lu\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_pivoted\_lu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_pivoted\_lu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_polar\_decomposition}}{cas\_polar\_decomposition}}\label{cas_polar_decomposition}

\texttt{cas\_polar\_decomposition} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_polar\_decomposition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_polar\_decomposition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_polya\_enumeration\_step}}{cas\_polya\_enumeration\_step}}\label{cas_polya_enumeration_step}

\texttt{cas\_polya\_enumeration\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_polya\_enumeration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_polya\_enumeration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_polynomial\_div\_step}}{cas\_polynomial\_div\_step}}\label{cas_polynomial_div_step}

\texttt{cas\_polynomial\_div\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_polynomial\_div\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_polynomial\_div\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_polynomial\_gcd\_step}}{cas\_polynomial\_gcd\_step}}\label{cas_polynomial_gcd_step}

\texttt{cas\_polynomial\_gcd\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_polynomial\_gcd\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_polynomial\_gcd\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_polynomial\_roots\_kahan}}{cas\_polynomial\_roots\_kahan}}\label{cas_polynomial_roots_kahan}

\texttt{cas\_polynomial\_roots\_kahan} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_polynomial\_roots\_kahan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_polynomial\_roots\_kahan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proj\_box}}{cas\_proj\_box}}\label{cas_proj_box}

\texttt{cas\_proj\_box} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proj\_box $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proj\_box |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proj\_exp\_cone}}{cas\_proj\_exp\_cone}}\label{cas_proj_exp_cone}

\texttt{cas\_proj\_exp\_cone} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proj\_exp\_cone $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proj\_exp\_cone |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proj\_l1\_ball}}{cas\_proj\_l1\_ball}}\label{cas_proj_l1_ball}

\texttt{cas\_proj\_l1\_ball} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proj\_l1\_ball $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proj\_l1\_ball |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proj\_l2\_ball}}{cas\_proj\_l2\_ball}}\label{cas_proj_l2_ball}

\texttt{cas\_proj\_l2\_ball} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proj\_l2\_ball $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proj\_l2\_ball |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proj\_psd\_cone}}{cas\_proj\_psd\_cone}}\label{cas_proj_psd_cone}

\texttt{cas\_proj\_psd\_cone} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proj\_psd\_cone $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proj\_psd\_cone |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proj\_soc\_step}}{cas\_proj\_soc\_step}}\label{cas_proj_soc_step}

\texttt{cas\_proj\_soc\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proj\_soc\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proj\_soc\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proximal\_l1\_step}}{cas\_proximal\_l1\_step}}\label{cas_proximal_l1_step}

\texttt{cas\_proximal\_l1\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proximal\_l1\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proximal\_l1\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proximal\_l2\_step}}{cas\_proximal\_l2\_step}}\label{cas_proximal_l2_step}

\texttt{cas\_proximal\_l2\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proximal\_l2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proximal\_l2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_proximal\_l\_inf\_step}}{cas\_proximal\_l\_inf\_step}}\label{cas_proximal_l_inf_step}

\texttt{cas\_proximal\_l\_inf\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_proximal\_l\_inf\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_proximal\_l\_inf\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_pseudoinverse\_step}}{cas\_pseudoinverse\_step}}\label{cas_pseudoinverse_step}

\texttt{cas\_pseudoinverse\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_pseudoinverse\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_pseudoinverse\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_qr\_iteration\_step}}{cas\_qr\_iteration\_step}}\label{cas_qr_iteration_step}

\texttt{cas\_qr\_iteration\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_qr\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_qr\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_quasi\_triangular}}{cas\_quasi\_triangular}}\label{cas_quasi_triangular}

\texttt{cas\_quasi\_triangular} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_quasi\_triangular $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_quasi\_triangular |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_radical\_simplify}}{cas\_radical\_simplify}}\label{cas_radical_simplify}

\texttt{cas\_radical\_simplify} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_radical\_simplify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_radical\_simplify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_rank\_revealing\_qr}}{cas\_rank\_revealing\_qr}}\label{cas_rank_revealing_qr}

\texttt{cas\_rank\_revealing\_qr} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_rank\_revealing\_qr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_rank\_revealing\_qr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_regularized\_lsq\_tikhonov}}{cas\_regularized\_lsq\_tikhonov}}\label{cas_regularized_lsq_tikhonov}

\texttt{cas\_regularized\_lsq\_tikhonov} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_regularized\_lsq\_tikhonov $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_regularized\_lsq\_tikhonov |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_resultant\_two}}{cas\_resultant\_two}}\label{cas_resultant_two}

\texttt{cas\_resultant\_two} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_resultant\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_resultant\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_resultant\_x\_y}}{cas\_resultant\_x\_y}}\label{cas_resultant_x_y}

\texttt{cas\_resultant\_x\_y} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_resultant\_x\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_resultant\_x\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_riccati\_continuous\_step}}{cas\_riccati\_continuous\_step}}\label{cas_riccati_continuous_step}

\texttt{cas\_riccati\_continuous\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_riccati\_continuous\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_riccati\_continuous\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_riccati\_discrete\_step}}{cas\_riccati\_discrete\_step}}\label{cas_riccati_discrete_step}

\texttt{cas\_riccati\_discrete\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_riccati\_discrete\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_riccati\_discrete\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_root\_isolate\_step}}{cas\_root\_isolate\_step}}\label{cas_root_isolate_step}

\texttt{cas\_root\_isolate\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_root\_isolate\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_root\_isolate\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_schur\_decomposition\_step}}{cas\_schur\_decomposition\_step}}\label{cas_schur_decomposition_step}

\texttt{cas\_schur\_decomposition\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_schur\_decomposition\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_schur\_decomposition\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_simplify\_term}}{cas\_simplify\_term}}\label{cas_simplify_term}

\texttt{cas\_simplify\_term} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_simplify\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_simplify\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_singular\_value\_step}}{cas\_singular\_value\_step}}\label{cas_singular_value_step}

\texttt{cas\_singular\_value\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_singular\_value\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_singular\_value\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_smith\_normal\_step}}{cas\_smith\_normal\_step}}\label{cas_smith_normal_step}

\texttt{cas\_smith\_normal\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_smith\_normal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_smith\_normal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_solve\_cubic}}{cas\_solve\_cubic}}\label{cas_solve_cubic}

\texttt{cas\_solve\_cubic} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_solve\_cubic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_solve\_cubic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_solve\_linear}}{cas\_solve\_linear}}\label{cas_solve_linear}

\texttt{cas\_solve\_linear} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_solve\_linear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_solve\_linear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_solve\_polynomial\_n}}{cas\_solve\_polynomial\_n}}\label{cas_solve_polynomial_n}

\texttt{cas\_solve\_polynomial\_n} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_solve\_polynomial\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_solve\_polynomial\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_solve\_quadratic}}{cas\_solve\_quadratic}}\label{cas_solve_quadratic}

\texttt{cas\_solve\_quadratic} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_solve\_quadratic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_solve\_quadratic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_solve\_quartic}}{cas\_solve\_quartic}}\label{cas_solve_quartic}

\texttt{cas\_solve\_quartic} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_solve\_quartic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_solve\_quartic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_sturm\_sequence\_step}}{cas\_sturm\_sequence\_step}}\label{cas_sturm_sequence_step}

\texttt{cas\_sturm\_sequence\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_sturm\_sequence\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_sturm\_sequence\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_subresultant\_two}}{cas\_subresultant\_two}}\label{cas_subresultant_two}

\texttt{cas\_subresultant\_two} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_subresultant\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_subresultant\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_sylvester\_equation\_step}}{cas\_sylvester\_equation\_step}}\label{cas_sylvester_equation_step}

\texttt{cas\_sylvester\_equation\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_sylvester\_equation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_sylvester\_equation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_taylor\_coefficient}}{cas\_taylor\_coefficient}}\label{cas_taylor_coefficient}

\texttt{cas\_taylor\_coefficient} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_taylor\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_taylor\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_total\_least\_squares}}{cas\_total\_least\_squares}}\label{cas_total_least_squares}

\texttt{cas\_total\_least\_squares} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_total\_least\_squares $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_total\_least\_squares |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_truncated\_lsq}}{cas\_truncated\_lsq}}\label{cas_truncated_lsq}

\texttt{cas\_truncated\_lsq} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_truncated\_lsq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_truncated\_lsq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_truncated\_svd\_value}}{cas\_truncated\_svd\_value}}\label{cas_truncated_svd_value}

\texttt{cas\_truncated\_svd\_value} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_truncated\_svd\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_truncated\_svd\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_vec\_operator\_step}}{cas\_vec\_operator\_step}}\label{cas_vec_operator_step}

\texttt{cas\_vec\_operator\_step} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_vec\_operator\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_vec\_operator\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cas\_woodbury\_identity}}{cas\_woodbury\_identity}}\label{cas_woodbury_identity}

\texttt{cas\_woodbury\_identity} --- batch 44 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cas\_woodbury\_identity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cas\_woodbury\_identity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{casimir\_eigenvalue\_su2}}{casimir\_eigenvalue\_su2}}\label{casimir_eigenvalue_su2}

\texttt{casimir\_eigenvalue\_su2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = casimir\_eigenvalue\_su2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map casimir\_eigenvalue\_su2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{catalan}}{catalan}}\label{catalan}

\texttt{catalan\_constant} (alias \texttt{catalan}) ---
Catalan\textquotesingle s constant G ≈ 0.9159. Appears in combinatorics
and series.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p catalan   \# 0.9159655941772190}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{catn}}{catn}}\label{catn}

\texttt{catn} --- extended stdlib batch 3 builtin. Alias for
\texttt{catalan}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = catn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map catn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cauchy\_pdf}}{cauchy\_pdf}}\label{cauchy_pdf}

\texttt{cauchy\_pdf} (alias \texttt{cauchypdf}) evaluates the Cauchy
distribution PDF at x with location x0 and scale gamma.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cauchypdf(0, 0, 1)  \# peak of standard Cauchy}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{caverphone\_2}}{caverphone\_2}}\label{caverphone_2}

\texttt{caverphone\_2} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = caverphone\_2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map caverphone\_2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cbind}}{cbind}}\label{cbind}

\texttt{cbind} --- bind matrices by columns (horizontal join). Like
R\textquotesingle s cbind().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $m = cbind([[1],[2]], [[3],[4]])  \# [[1,3],[2,4]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cblend}}{cblend}}\label{cblend}

\texttt{cblend} --- color operations builtin. Alias for
\texttt{color\_blend}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cblend $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cblend |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cbor\_encode\_str}}{cbor\_encode\_str}}\label{cbor_encode_str}

\texttt{cbor\_encode\_str} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cbor\_encode\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cbor\_encode\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cbor\_encode\_uint}}{cbor\_encode\_uint}}\label{cbor_encode_uint}

\texttt{cbor\_encode\_uint} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cbor\_encode\_uint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cbor\_encode\_uint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cbrt}}{cbrt}}\label{cbrt}

\texttt{cbrt} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cbrt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cbrt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cc\_count}}{cc\_count}}\label{cc_count}

\texttt{cc\_count} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cc\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cc\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cc\_labels}}{cc\_labels}}\label{cc_labels}

\texttt{cc\_labels} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cc\_labels $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cc\_labels |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ccgraph}}{ccgraph}}\label{ccgraph}

\texttt{ccgraph} --- extended stdlib builtin. Alias for
\texttt{connected\_components\_graph}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ccgraph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ccgraph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ccompl}}{ccompl}}\label{ccompl}

\texttt{ccompl} --- color operations builtin. Alias for
\texttt{color\_complement}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ccompl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ccompl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ccount}}{ccount}}\label{ccount}

\texttt{ccount} --- extended stdlib batch 3 builtin. Alias for
\texttt{count\_chars}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ccount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ccount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ccx\_gate}}{ccx\_gate}}\label{ccx_gate}

\texttt{ccx\_gate} --- batches 14-16 builtin. Alias for
\texttt{toffoli\_gate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ccx\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ccx\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cdarken}}{cdarken}}\label{cdarken}

\texttt{cdarken} --- color operations builtin. Alias for
\texttt{color\_darken}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cdarken $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cdarken |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cdist}}{cdist}}\label{cdist}

\texttt{cdist} --- color operations builtin. Alias for
\texttt{color\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cds\_upfront}}{cds\_upfront}}\label{cds_upfront}

\texttt{cds\_upfront} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cds\_upfront $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cds\_upfront |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cech\_zero\_cohomology}}{cech\_zero\_cohomology}}\label{cech_zero_cohomology}

\texttt{cech\_zero\_cohomology} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cech\_zero\_cohomology $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cech\_zero\_cohomology |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ceil}}{ceil}}\label{ceil}

\texttt{ceil} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ceil $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ceil |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ceil\_div}}{ceil\_div}}\label{ceil_div}

\texttt{ceil\_div} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ceil\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ceil\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ceil\_each}}{ceil\_each}}\label{ceil_each}

\texttt{ceil\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ceil\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ceil\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ceiling}}{ceiling}}\label{ceiling}

\texttt{ceiling} --- trivial numeric / predicate builtins builtin. Alias
for \texttt{ceil}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ceiling $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ceiling |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{center}}{center}}\label{center}

\texttt{center} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = center $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map center |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{center\_text}}{center\_text}}\label{center_text}

\texttt{center\_text} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = center\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map center\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centered\_hexagonal\_number}}{centered\_hexagonal\_number}}\label{centered_hexagonal_number}

\texttt{centered\_hexagonal\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centered\_hexagonal\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centered\_hexagonal\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centered\_pentagonal}}{centered\_pentagonal}}\label{centered_pentagonal}

\texttt{centered\_pentagonal} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centered\_pentagonal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centered\_pentagonal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centered\_square}}{centered\_square}}\label{centered_square}

\texttt{centered\_square} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centered\_square $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centered\_square |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centered\_triangular}}{centered\_triangular}}\label{centered_triangular}

\texttt{centered\_triangular} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centered\_triangular $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centered\_triangular |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{central\_polygonal}}{central\_polygonal}}\label{central_polygonal}

\texttt{central\_polygonal} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = central\_polygonal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map central\_polygonal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centrality\_betweenness}}{centrality\_betweenness}}\label{centrality_betweenness}

\texttt{centrality\_betweenness} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centrality\_betweenness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centrality\_betweenness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centrality\_closeness}}{centrality\_closeness}}\label{centrality_closeness}

\texttt{centrality\_closeness} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centrality\_closeness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centrality\_closeness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centrality\_degree}}{centrality\_degree}}\label{centrality_degree}

\texttt{centrality\_degree} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centrality\_degree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centrality\_degree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centrality\_eigenvector}}{centrality\_eigenvector}}\label{centrality_eigenvector}

\texttt{centrality\_eigenvector} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centrality\_eigenvector $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centrality\_eigenvector |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centrality\_katz}}{centrality\_katz}}\label{centrality_katz}

\texttt{centrality\_katz} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centrality\_katz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centrality\_katz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centrip}}{centrip}}\label{centrip}

\texttt{centripetal\_force(\$mass,\ \$velocity,\ \$radius)} (alias
\texttt{centrip}) --- F = mv²/r for circular motion.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p centrip(1000, 20, 50)   \# 8000 N (car turning)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centripetal\_accel}}{centripetal\_accel}}\label{centripetal_accel}

\texttt{centripetal\_accel} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centripetal\_accel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centripetal\_accel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centroid}}{centroid}}\label{centroid}

\texttt{centroid(@points)} --- computes the centroid (geometric center)
of 2D points. Points as flat list {[}x1,y1,x2,y2,...{]}. Returns
{[}\$cx, \$cy{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @triangle = (0,0, 3,0, 0,3)}
\NormalTok{my $c = centroid(@triangle)}
\NormalTok{p @$c   \# (1, 1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{centroid\_nd}}{centroid\_nd}}\label{centroid_nd}

\texttt{centroid\_nd} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = centroid\_nd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map centroid\_nd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cents\_between}}{cents\_between}}\label{cents_between}

\texttt{cents\_between} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cents\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cents\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cents\_between\_freqs}}{cents\_between\_freqs}}\label{cents_between_freqs}

\texttt{cents\_between\_freqs} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cents\_between\_freqs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cents\_between\_freqs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ces\_production}}{ces\_production}}\label{ces_production}

\texttt{ces\_production} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ces\_production $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ces\_production |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cfl\_number}}{cfl\_number}}\label{cfl_number}

\texttt{cfl\_number} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cfl\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cfl\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cfr\_case\_fatality}}{cfr\_case\_fatality}}\label{cfr_case_fatality}

\texttt{cfr\_case\_fatality} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cfr\_case\_fatality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cfr\_case\_fatality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cg\_beta\_fr}}{cg\_beta\_fr}}\label{cg_beta_fr}

\texttt{cg\_beta\_fr} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cg\_beta\_fr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cg\_beta\_fr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cg\_beta\_pr}}{cg\_beta\_pr}}\label{cg_beta_pr}

\texttt{cg\_beta\_pr} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cg\_beta\_pr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cg\_beta\_pr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cg\_simple}}{cg\_simple}}\label{cg_simple}

\texttt{cg\_simple} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cg\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cg\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cgemm}}{cgemm}}\label{cgemm}

\texttt{cgemm} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cgemm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cgemm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cgray}}{cgray}}\label{cgray}

\texttt{cgray} --- color operations builtin. Alias for
\texttt{color\_grayscale}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cgray $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cgray |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chacha20\_qround}}{chacha20\_qround}}\label{chacha20_qround}

\texttt{chacha20\_qround} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chacha20\_qround $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chacha20\_qround |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chain\_from}}{chain\_from}}\label{chain_from}

\texttt{chain\_from} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chain\_from $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chain\_from |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chain\_ladder\_step}}{chain\_ladder\_step}}\label{chain_ladder_step}

\texttt{chain\_ladder\_step} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chain\_ladder\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chain\_ladder\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chain\_rule\_entropy}}{chain\_rule\_entropy}}\label{chain_rule_entropy}

\texttt{chain\_rule\_entropy} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chain\_rule\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chain\_rule\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chandrasekhar\_mass}}{chandrasekhar\_mass}}\label{chandrasekhar_mass}

\texttt{chandrasekhar\_mass} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chandrasekhar\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chandrasekhar\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chapman\_estimator}}{chapman\_estimator}}\label{chapman_estimator}

\texttt{chapman\_estimator} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chapman\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chapman\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{char\_at}}{char\_at}}\label{char_at}

\texttt{char\_at} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = char\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map char\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{char\_count}}{char\_count}}\label{char_count}

\texttt{char\_count} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = char\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map char\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{char\_devices}}{char\_devices}}\label{char_devices}

\texttt{char\_devices} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = char\_devices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map char\_devices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{char\_frequencies}}{char\_frequencies}}\label{char_frequencies}

\texttt{char\_frequencies} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = char\_frequencies $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map char\_frequencies |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{char\_length}}{char\_length}}\label{char_length}

\texttt{char\_length} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = char\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map char\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{character\_su2}}{character\_su2}}\label{character_su2}

\texttt{character\_su2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = character\_su2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map character\_su2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{character\_sun}}{character\_sun}}\label{character_sun}

\texttt{character\_sun} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = character\_sun $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map character\_sun |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{characteristic\_function}}{characteristic\_function}}\label{characteristic_function}

\texttt{characteristic\_function} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = characteristic\_function $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map characteristic\_function |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{charcodes\_to\_string}}{charcodes\_to\_string}}\label{charcodes_to_string}

\texttt{charcodes\_to\_string} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = charcodes\_to\_string $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{charfreq}}{charfreq}}\label{charfreq}

\texttt{charfreq} --- string processing (uncategorized batch) builtin.
Alias for \texttt{char\_frequencies}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = charfreq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map charfreq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{charge\_capacity\_battery}}{charge\_capacity\_battery}}\label{charge_capacity_battery}

\texttt{charge\_capacity\_battery} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = charge\_capacity\_battery $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map charge\_capacity\_battery |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{charge\_transfer\_resistance}}{charge\_transfer\_resistance}}\label{charge_transfer_resistance}

\texttt{charge\_transfer\_resistance} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = charge\_transfer\_resistance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map charge\_transfer\_resistance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chars\_to\_string}}{chars\_to\_string}}\label{chars_to_string}

\texttt{chars\_to\_string} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chars\_to\_string $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chc\_bound\_makespan}}{chc\_bound\_makespan}}\label{chc_bound_makespan}

\texttt{chc\_bound\_makespan} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chc\_bound\_makespan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chc\_bound\_makespan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cheapest\_insertion\_step}}{cheapest\_insertion\_step}}\label{cheapest_insertion_step}

\texttt{cheapest\_insertion\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cheapest\_insertion\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cheapest\_insertion\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cheby1\_lp}}{cheby1\_lp}}\label{cheby1_lp}

\texttt{cheby1\_lp} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cheby1\_lp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cheby1\_lp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cheby2\_lp}}{cheby2\_lp}}\label{cheby2_lp}

\texttt{cheby2\_lp} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cheby2\_lp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cheby2\_lp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chebyshev\_distance}}{chebyshev\_distance}}\label{chebyshev_distance}

\texttt{chebyshev\_distance} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chebyshev\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chebyshev\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chebyt}}{chebyt}}\label{chebyt}

\texttt{chebyt} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chebyt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chebyt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chebyu}}{chebyu}}\label{chebyu}

\texttt{chebyu} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chebyu $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chebyu |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chern\_first\_2d}}{chern\_first\_2d}}\label{chern_first_2d}

\texttt{chern\_first\_2d} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chern\_first\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chern\_first\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chern\_pontryagin\_4d\_step}}{chern\_pontryagin\_4d\_step}}\label{chern_pontryagin_4d_step}

\texttt{chern\_pontryagin\_4d\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chern\_pontryagin\_4d\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chern\_pontryagin\_4d\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chern\_simons\_action}}{chern\_simons\_action}}\label{chern_simons_action}

\texttt{chern\_simons\_action} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chern\_simons\_action $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chern\_simons\_action |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chezy\_velocity}}{chezy\_velocity}}\label{chezy_velocity}

\texttt{chezy\_velocity} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chezy\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chezy\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chfr}}{chfr}}\label{chfr}

\texttt{chfr} --- python/ruby stdlib builtin. Alias for
\texttt{chain\_from}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chfr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chfr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chi2}}{chi2}}\label{chi2}

\texttt{chi\_square\_stat(\textbackslash{}@observed,\ \textbackslash{}@expected)}
(alias \texttt{chi2}) --- computes the chi-squared test statistic
comparing observed vs expected frequencies. Useful for goodness-of-fit
tests. Returns the chi-squared value.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @obs = (10, 20, 30)}
\NormalTok{my @exp = (15, 20, 25)}
\NormalTok{p chi2(\textbackslash{}@obs, \textbackslash{}@exp)   \# chi{-}squared statistic}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chi2\_pdf}}{chi2\_pdf}}\label{chi2_pdf}

\texttt{chi2\_pdf} (alias \texttt{chi2pdf}) evaluates the chi-squared
distribution PDF at x with k degrees of freedom.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p chi2pdf(3.84, 1)  \# p{-}value boundary for df=1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chicken\_game\_payoff}}{chicken\_game\_payoff}}\label{chicken_game_payoff}

\texttt{chicken\_game\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chicken\_game\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chicken\_game\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chinese\_lunation\_winter}}{chinese\_lunation\_winter}}\label{chinese_lunation_winter}

\texttt{chinese\_lunation\_winter} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chinese\_lunation\_winter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chinese\_lunation\_winter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chinese\_new\_year}}{chinese\_new\_year}}\label{chinese_new_year}

\texttt{chinese\_new\_year} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chinese\_new\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chinese\_new\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chinese\_remainder}}{chinese\_remainder}}\label{chinese_remainder}

\texttt{chinese\_remainder} (alias \texttt{crt}) solves a system of
simultaneous congruences via the Chinese Remainder Theorem.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p crt([2,3,2], [3,5,7])  \# 23 (x≡2 mod 3, x≡3 mod 5, x≡2 mod 7)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chinese\_year\_zodiac}}{chinese\_year\_zodiac}}\label{chinese_year_zodiac}

\texttt{chinese\_year\_zodiac} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chinese\_year\_zodiac $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chinese\_year\_zodiac |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chinese\_zodiac}}{chinese\_zodiac}}\label{chinese_zodiac}

\texttt{chinese\_zodiac} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chinese\_zodiac $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chinese\_zodiac |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chirp}}{chirp}}\label{chirp}

\texttt{chirp} generates a linear chirp signal sweeping from f0 to f1
Hz. Args: n\_samples, f0, f1, sample\_rate.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @sig = @\{chirp(1000, 100, 1000, 8000)\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chirp\_linear}}{chirp\_linear}}\label{chirp_linear}

\texttt{chirp\_linear} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chirp\_linear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chirp\_linear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chirp\_mass}}{chirp\_mass}}\label{chirp_mass}

\texttt{chirp\_mass} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chirp\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chirp\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chirp\_mass\_inspiral\_step}}{chirp\_mass\_inspiral\_step}}\label{chirp_mass_inspiral_step}

\texttt{chirp\_mass\_inspiral\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chirp\_mass\_inspiral\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chirp\_mass\_inspiral\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chisquare\_metric}}{chisquare\_metric}}\label{chisquare_metric}

\texttt{chisquare\_metric} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chisquare\_metric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chisquare\_metric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chkstr}}{chkstr}}\label{chkstr}

\texttt{chkstr} --- string processing (uncategorized batch) builtin.
Alias for \texttt{chunk\_string}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chkstr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chkstr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chkw}}{chkw}}\label{chkw}

\texttt{chkw} --- ruby enumerable extras builtin. Alias for
\texttt{chunk\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chkw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chkw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chlorine\_radical\_decay}}{chlorine\_radical\_decay}}\label{chlorine_radical_decay}

\texttt{chlorine\_radical\_decay} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chlorine\_radical\_decay $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chlorine\_radical\_decay |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cholesky}}{cholesky}}\label{cholesky}

\texttt{matrix\_cholesky} (aliases \texttt{mchol}, \texttt{cholesky})
computes the Cholesky decomposition of a symmetric positive-definite
matrix. Returns lower-triangular L where M = L·L\^{}T.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $L = cholesky([[4,2],[2,3]])}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chomp\_str}}{chomp\_str}}\label{chomp_str}

\texttt{chomp\_str} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chomp\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chomp\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{choose}}{choose}}\label{choose}

\texttt{choose} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = choose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map choose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chop\_str}}{chop\_str}}\label{chop_str}

\texttt{chop\_str} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chop\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chop\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chord\_quality\_classify}}{chord\_quality\_classify}}\label{chord_quality_classify}

\texttt{chord\_quality\_classify} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chord\_quality\_classify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chord\_quality\_classify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chord\_root\_inversion}}{chord\_root\_inversion}}\label{chord_root_inversion}

\texttt{chord\_root\_inversion} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chord\_root\_inversion $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chord\_root\_inversion |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chord\_to\_freqs}}{chord\_to\_freqs}}\label{chord_to_freqs}

\texttt{chord\_to\_freqs} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chord\_to\_freqs $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chord\_voicing\_close}}{chord\_voicing\_close}}\label{chord_voicing_close}

\texttt{chord\_voicing\_close} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chord\_voicing\_close $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chord\_voicing\_close |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chow\_test\_stat}}{chow\_test\_stat}}\label{chow_test_stat}

\texttt{chow\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chow\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chow\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{christoffel\_first\_kind\_step}}{christoffel\_first\_kind\_step}}\label{christoffel_first_kind_step}

\texttt{christoffel\_first\_kind\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = christoffel\_first\_kind\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map christoffel\_first\_kind\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{christoffel\_second\_kind\_step}}{christoffel\_second\_kind\_step}}\label{christoffel_second_kind_step}

\texttt{christoffel\_second\_kind\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = christoffel\_second\_kind\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map christoffel\_second\_kind\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{christoffel\_symbol\_normalize}}{christoffel\_symbol\_normalize}}\label{christoffel_symbol_normalize}

\texttt{christoffel\_symbol\_normalize} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = christoffel\_symbol\_normalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map christoffel\_symbol\_normalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{christoffel\_word}}{christoffel\_word}}\label{christoffel_word}

\texttt{christoffel\_word} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = christoffel\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map christoffel\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{christofides\_ratio\_bound}}{christofides\_ratio\_bound}}\label{christofides_ratio_bound}

\texttt{christofides\_ratio\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = christofides\_ratio\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map christofides\_ratio\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chroma\_feature\_step}}{chroma\_feature\_step}}\label{chroma_feature_step}

\texttt{chroma\_feature\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chroma\_feature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chroma\_feature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chromatic\_homology\_rank}}{chromatic\_homology\_rank}}\label{chromatic_homology_rank}

\texttt{chromatic\_homology\_rank} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chromatic\_homology\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chromatic\_homology\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chromatic\_number\_greedy}}{chromatic\_number\_greedy}}\label{chromatic_number_greedy}

\texttt{chromatic\_number\_greedy} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chromatic\_number\_greedy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chromatic\_number\_greedy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chroot}}{chroot}}\label{chroot}

\texttt{chroot} --- process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chroot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chroot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chsh\_expectation}}{chsh\_expectation}}\label{chsh_expectation}

\texttt{chsh\_expectation} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chsh\_expectation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chsh\_expectation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chull}}{chull}}\label{chull}

\texttt{convex\_hull(@points)} (alias \texttt{chull}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @pts = (0,0, 1,1, 2,0, 1,0.5)}
\NormalTok{my $hull = chull(@pts)}
\NormalTok{p @$hull}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chunk\_by}}{chunk\_by}}\label{chunk_by}

\texttt{chunk\_by} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chunk\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chunk\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chunk\_n}}{chunk\_n}}\label{chunk_n}

\texttt{chunk\_n} --- collection (batch 2) builtin. Alias for
\texttt{group\_of\_n}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chunk\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chunk\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chunk\_string}}{chunk\_string}}\label{chunk_string}

\texttt{chunk\_string} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chunk\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chunk\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chunk\_while}}{chunk\_while}}\label{chunk_while}

\texttt{chunk\_while} --- ruby enumerable extras builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chunk\_while $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chunk\_while |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{church\_numeral\_n}}{church\_numeral\_n}}\label{church_numeral_n}

\texttt{church\_numeral\_n} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = church\_numeral\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map church\_numeral\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{chvatal\_gomory\_cut}}{chvatal\_gomory\_cut}}\label{chvatal_gomory_cut}

\texttt{chvatal\_gomory\_cut} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = chvatal\_gomory\_cut $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map chvatal\_gomory\_cut |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ci}}{ci}}\label{ci}

\texttt{confidence\_interval} (alias \texttt{ci}) computes a confidence
interval for the mean. Default 95\%. Returns {[}lower, upper{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($lo, $hi) = @\{ci([10,12,14,11,13])\}}
\NormalTok{p "95\%\% CI: $lo to $hi"}
\NormalTok{my ($lo99, $hi99) = @\{ci([10,12,14,11,13], 0.99)\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cindex}}{cindex}}\label{cindex}

\texttt{cindex\ STRING,\ SUBSTRING\ {[},\ FROM{]}} --- codepoint-indexed
equivalent of Perl 5\textquotesingle s \texttt{index}. Returns the
zero-based codepoint position of the first occurrence, or -1 on miss.
FROM is also a codepoint position. Pairs with \texttt{{[}i{]}} /
\texttt{{[}a:b{]}} slice operators and \texttt{len} so search positions
and slice bounds share one coordinate system.

Use \texttt{cindex} whenever your code mixes string search with
\texttt{{[}{]}} slicing --- Perl 5 \texttt{index} returns byte positions
and silently misaligns when fed into \texttt{{[}{]}} (which is
codepoint-based). \texttt{index} stays byte-indexed because
\texttt{length} and \texttt{substr} are, and changing it would break
Perl-5 binary-protocol code; \texttt{cindex} is the stryke-extension
counterpart.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = "hello ─ world"}
\NormalTok{p index  $s, "world"        \# 9 (bytes — \textasciigrave{}─\textasciigrave{} is 3 bytes)}
\NormalTok{p cindex $s, "world"        \# 7 (codepoints)}
\NormalTok{my $i = cindex $s, "world"}
\NormalTok{p $s[$i : len($s) {-} 1]      \# "world" — slice bounds line up}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cinv}}{cinv}}\label{cinv}

\texttt{cinv} --- extended stdlib batch 3 builtin. Alias for
\texttt{count\_inversions}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cinv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cinv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cinvert}}{cinvert}}\label{cinvert}

\texttt{cinvert} --- color operations builtin. Alias for
\texttt{color\_invert}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cinvert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cinvert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cir\_bond}}{cir\_bond}}\label{cir_bond}

\texttt{cir\_bond} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cir\_bond $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cir\_bond |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circ3pt}}{circ3pt}}\label{circ3pt}

\texttt{circ3pt} --- geometry (extended) builtin. Alias for
\texttt{circle\_from\_three\_points}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circ3pt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circ3pt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circle\_3\_points}}{circle\_3\_points}}\label{circle_3_points}

\texttt{circle\_3\_points} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circle\_3\_points $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circle\_3\_points |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circle\_from\_three\_points}}{circle\_from\_three\_points}}\label{circle_from_three_points}

\texttt{circle\_from\_three\_points(\$x1,\ \$y1,\ \$x2,\ \$y2,\ \$x3,\ \$y3)}
(alias \texttt{circ3}) --- finds the unique circle passing through three
non-collinear points. Returns {[}\$cx, \$cy, \$radius{]} or undef if
collinear.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $c = circ3(0, 0, 1, 0, 0.5, 0.866)}
\NormalTok{p "center=($c{-}\textgreater{}[0], $c{-}\textgreater{}[1]) r=$c{-}\textgreater{}[2]"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circle\_of\_fifths\_step}}{circle\_of\_fifths\_step}}\label{circle_of_fifths_step}

\texttt{circle\_of\_fifths\_step} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circle\_of\_fifths\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circle\_of\_fifths\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circuit\_depth}}{circuit\_depth}}\label{circuit_depth}

\texttt{circuit\_depth} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circuit\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circuit\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circuit\_width}}{circuit\_width}}\label{circuit_width}

\texttt{circuit\_width} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circuit\_width $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circuit\_width |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circum}}{circum}}\label{circum}

\texttt{circum} --- geometry / physics builtin. Alias for
\texttt{circumference}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{circumference}}{circumference}}\label{circumference}

\texttt{circumference} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = circumference $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map circumference |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cityhash64}}{cityhash64}}\label{cityhash64}

\texttt{cityhash64} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cityhash64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cityhash64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clamp\_array}}{clamp\_array}}\label{clamp_array}

\texttt{clamp\_array} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clamp\_array $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clamp\_array |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clamp\_each}}{clamp\_each}}\label{clamp_each}

\texttt{clamp\_each} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clamp\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clamp\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clamp\_fn}}{clamp\_fn}}\label{clamp_fn}

\texttt{clamp\_fn} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clamp\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clamp\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clamp\_int}}{clamp\_int}}\label{clamp_int}

\texttt{clamp\_int} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clamp\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clamp\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clamp\_list}}{clamp\_list}}\label{clamp_list}

\texttt{clamp\_list} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clamp\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clamp\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clarr}}{clarr}}\label{clarr}

\texttt{clarr} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{clamp\_array}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clarr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clarr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{class}}{class}}\label{class}

\texttt{class} 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.

\textbf{Declaration:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Animal \{}
\NormalTok{    name: Str}
\NormalTok{    age: Int = 0}
\NormalTok{    fn speak \{ p "Animal: " . $self{-}\textgreater{}name \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\textbf{Inheritance with \texttt{extends}:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Dog extends Animal \{}
\NormalTok{    breed: Str = "Mixed"}
\NormalTok{    fn bark \{ p "Woof! I am " . $self{-}\textgreater{}name \}}
\NormalTok{    fn speak \{ p $self{-}\textgreater{}name . " barks!" \}  \# override}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\textbf{Construction (named or positional):}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $dog = Dog(name =\textgreater{} "Rex", age =\textgreater{} 5, breed =\textgreater{} "Lab")}
\NormalTok{my $dog = Dog("Rex", 5, "Lab")  \# positional}
\end{Highlighting}
\end{Shaded}

\textbf{Field access (getter/setter):}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $dog{-}\textgreater{}name      \# getter}
\NormalTok{$dog{-}\textgreater{}age(6)      \# setter}
\end{Highlighting}
\end{Shaded}

\textbf{Static methods (\texttt{fn\ Self.name}):}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Math \{}
\NormalTok{    fn Self.add($a, $b) \{ $a + $b \}}
\NormalTok{    fn Self.pi \{ 3.14159 \}}
\NormalTok{\}}
\NormalTok{p Math::add(3, 4)  \# 7}
\NormalTok{p Math::pi()       \# 3.14159}
\end{Highlighting}
\end{Shaded}

\textbf{Traits (interfaces):}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{trait Printable \{ fn to\_str \}}
\NormalTok{class Item impl Printable \{}
\NormalTok{    name: Str}
\NormalTok{    fn to\_str \{ $self{-}\textgreater{}name \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\textbf{Multiple inheritance:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class C extends A, B \{ \}}
\end{Highlighting}
\end{Shaded}

\textbf{isa checks:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p $dog{-}\textgreater{}isa("Dog")    \# 1}
\NormalTok{p $dog{-}\textgreater{}isa("Animal") \# 1 (parent)}
\NormalTok{p $dog{-}\textgreater{}isa("Cat")    \# "" (false)}
\end{Highlighting}
\end{Shaded}

\textbf{Built-in methods:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @f = $dog{-}\textgreater{}fields()        \# (name, age, breed)}
\NormalTok{my $h = $dog{-}\textgreater{}to\_hash()       \# \{ name =\textgreater{} "Rex", ... \}}
\NormalTok{my $d2 = $dog{-}\textgreater{}with(age =\textgreater{} 1) \# functional update}
\NormalTok{my $d3 = $dog{-}\textgreater{}clone()        \# deep copy}
\end{Highlighting}
\end{Shaded}

\textbf{Visibility (pub/priv):}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Secret \{}
\NormalTok{    pub visible: Int = 1}
\NormalTok{    priv hidden: Int = 42}
\NormalTok{    pub fn get\_hidden \{ $self{-}\textgreater{}hidden \}  \# internal access ok}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Note: inherited fields come first in the values array; method lookup
walks the inheritance chain.

\section{\texorpdfstring{\texttt{class\_number\_bound}}{class\_number\_bound}}\label{class_number_bound}

\texttt{class\_number\_bound} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = class\_number\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map class\_number\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clausen\_cl2}}{clausen\_cl2}}\label{clausen_cl2}

\texttt{clausen\_cl2} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clausen\_cl2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clausen\_cl2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clausius\_clapeyron}}{clausius\_clapeyron}}\label{clausius_clapeyron}

\texttt{clausius\_clapeyron} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clausius\_clapeyron $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clausius\_clapeyron |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clausius\_clapeyron\_full}}{clausius\_clapeyron\_full}}\label{clausius_clapeyron_full}

\texttt{clausius\_clapeyron\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clausius\_clapeyron\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clausius\_clapeyron\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clean\_price}}{clean\_price}}\label{clean_price}

\texttt{clean\_price} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clean\_price $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clean\_price |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clighten}}{clighten}}\label{clighten}

\texttt{clighten} --- color operations builtin. Alias for
\texttt{color\_lighten}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clighten $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clighten |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clique\_count\_3}}{clique\_count\_3}}\label{clique_count_3}

\texttt{clique\_count\_3} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clique\_count\_3 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clique\_count\_3 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clique\_number\_lower}}{clique\_number\_lower}}\label{clique_number_lower}

\texttt{clique\_number\_lower} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clique\_number\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clique\_number\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{closed\_pipe\_harmonic}}{closed\_pipe\_harmonic}}\label{closed_pipe_harmonic}

\texttt{closed\_pipe\_harmonic} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = closed\_pipe\_harmonic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map closed\_pipe\_harmonic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{closest\_pt\_segment\_2d}}{closest\_pt\_segment\_2d}}\label{closest_pt_segment_2d}

\texttt{closest\_pt\_segment\_2d} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = closest\_pt\_segment\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map closest\_pt\_segment\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clpi}}{clpi}}\label{clpi}

\texttt{clpi} --- extended stdlib builtin. Alias for
\texttt{clamp\_int}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clpi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clpi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cluster\_attack\_rate}}{cluster\_attack\_rate}}\label{cluster_attack_rate}

\texttt{cluster\_attack\_rate} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cluster\_attack\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cluster\_attack\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cluster\_slots}}{cluster\_slots}}\label{cluster_slots}

\texttt{cluster\_slots} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cluster\_slots $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cluster\_slots |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clustering\_coefficient}}{clustering\_coefficient}}\label{clustering_coefficient}

\texttt{clustering\_coefficient} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clustering\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clustering\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{clutch\_score}}{clutch\_score}}\label{clutch_score}

\texttt{clutch\_score} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = clutch\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map clutch\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cm\_to\_inches}}{cm\_to\_inches}}\label{cm_to_inches}

\texttt{cm\_to\_inches} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cm\_to\_inches $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmap}}{cmap}}\label{cmap}

\texttt{cmap} --- additional missing stdlib functions builtin. Alias for
\texttt{concat\_map}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmb\_temperature}}{cmb\_temperature}}\label{cmb_temperature}

\texttt{cmb\_temperature} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmb\_temperature $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmb\_temperature |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmb\_temperature\_at\_z}}{cmb\_temperature\_at\_z}}\label{cmb_temperature_at_z}

\texttt{cmb\_temperature\_at\_z} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmb\_temperature\_at\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmb\_temperature\_at\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmd\_exists}}{cmd\_exists}}\label{cmd_exists}

\texttt{cmd\_exists} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmd\_exists $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmd\_exists |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmp\_num}}{cmp\_num}}\label{cmp_num}

\texttt{cmp\_num} --- file stat / path builtin. Alias for
\texttt{spaceship}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmp\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmp\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmp\_str}}{cmp\_str}}\label{cmp_str}

\texttt{cmp\_str} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmp\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmp\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmpr}}{cmpr}}\label{cmpr}

\texttt{cmpr} --- python/ruby stdlib builtin. Alias for
\texttt{compress}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmpr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cmpr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cmyk\_to\_rgb}}{cmyk\_to\_rgb}}\label{cmyk_to_rgb}

\texttt{cmyk\_to\_rgb} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cmyk\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cn\_coefficient}}{cn\_coefficient}}\label{cn_coefficient}

\texttt{cn\_coefficient} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cn\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cn\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cn\_ode}}{cn\_ode}}\label{cn_ode}

\texttt{cn\_ode} --- batch 19 builtin. Alias for
\texttt{crank\_nicolson\_ode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cn\_ode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cn\_ode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cnf\_dpll\_branch}}{cnf\_dpll\_branch}}\label{cnf_dpll_branch}

\texttt{cnf\_dpll\_branch} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cnf\_dpll\_branch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cnf\_dpll\_branch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cnf\_pure\_literal\_elim}}{cnf\_pure\_literal\_elim}}\label{cnf_pure_literal_elim}

\texttt{cnf\_pure\_literal\_elim} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cnf\_pure\_literal\_elim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cnf\_pure\_literal\_elim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cnf\_unit\_propagate}}{cnf\_unit\_propagate}}\label{cnf_unit_propagate}

\texttt{cnf\_unit\_propagate} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cnf\_unit\_propagate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cnf\_unit\_propagate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cnt}}{cnt}}\label{cnt}

\texttt{count} (aliases \texttt{len}, \texttt{cnt}) returns the number
of elements in a list, the \textbf{codepoint count} 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 \texttt{scalar\ @array} / \texttt{length\ \$string}
for stryke code; on strings it pairs with \texttt{{[}i{]}} /
\texttt{{[}a:b{]}} and \texttt{cindex} / \texttt{crindex}, all of which
use codepoint positions.

For byte length on a string, use Perl 5\textquotesingle s
\texttt{length} (kept byte-based for compat with \texttt{index} /
\texttt{rindex} / \texttt{substr}). \texttt{size} is NOT a count alias
--- it returns a file\textquotesingle s byte size.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @arr = (1, 2, 3, 4, 5)}
\NormalTok{p cnt @arr          \# 5}
\NormalTok{p len "hello"       \# 5}
\NormalTok{p len "─"           \# 1 (codepoint)}
\NormalTok{p length "─"        \# 3 (bytes)}
\NormalTok{my \%h = (a =\textgreater{} 1, b =\textgreater{} 2)}
\NormalTok{p cnt \textbackslash{}\%h           \# 2}
\NormalTok{rl("file.txt") |\textgreater{} cnt |\textgreater{} p  \# line count}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cntw}}{cntw}}\label{cntw}

\texttt{cntw} --- ruby enumerable extras builtin. Alias for
\texttt{count\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cntw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cntw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{co2\_growth\_rate\_step}}{co2\_growth\_rate\_step}}\label{co2_growth_rate_step}

\texttt{co2\_growth\_rate\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = co2\_growth\_rate\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map co2\_growth\_rate\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coalesce}}{coalesce}}\label{coalesce}

\texttt{coalesce} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coalesce $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coalesce |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coalescent\_expected\_time}}{coalescent\_expected\_time}}\label{coalescent_expected_time}

\texttt{coalescent\_expected\_time} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coalescent\_expected\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coalescent\_expected\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coalescent\_tree\_length}}{coalescent\_tree\_length}}\label{coalescent_tree_length}

\texttt{coalescent\_tree\_length} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coalescent\_tree\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coalescent\_tree\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cobb\_douglas}}{cobb\_douglas}}\label{cobb_douglas}

\texttt{cobb\_douglas} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cobb\_douglas $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cobb\_douglas |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{code\_point\_at}}{code\_point\_at}}\label{code_point_at}

\texttt{code\_point\_at} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = code\_point\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map code\_point\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{codifferential\_step}}{codifferential\_step}}\label{codifferential_step}

\texttt{codifferential\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = codifferential\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map codifferential\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{codon\_adaptation\_index}}{codon\_adaptation\_index}}\label{codon_adaptation_index}

\texttt{codon\_adaptation\_index} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = codon\_adaptation\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map codon\_adaptation\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{codon\_usage\_variance}}{codon\_usage\_variance}}\label{codon_usage_variance}

\texttt{codon\_usage\_variance} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = codon\_usage\_variance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map codon\_usage\_variance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coeff\_of\_variation}}{coeff\_of\_variation}}\label{coeff_of_variation}

\texttt{coeff\_of\_variation} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coeff\_of\_variation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coeff\_of\_variation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cognitive\_hierarchy\_step}}{cognitive\_hierarchy\_step}}\label{cognitive_hierarchy_step}

\texttt{cognitive\_hierarchy\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cognitive\_hierarchy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cognitive\_hierarchy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cohen\_d}}{cohen\_d}}\label{cohen_d}

\texttt{cohen\_d} (alias \texttt{cohend}) computes
Cohen\textquotesingle s d effect size between two samples. Small=0.2,
medium=0.5, large=0.8.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cohend([1,2,3], [4,5,6])  \# large effect}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cohen\_kappa}}{cohen\_kappa}}\label{cohen_kappa}

\texttt{cohen\_kappa} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cohen\_kappa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cohen\_kappa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coherence\_xy}}{coherence\_xy}}\label{coherence_xy}

\texttt{coherence\_xy} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coherence\_xy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coherence\_xy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coherent\_mean\_photons}}{coherent\_mean\_photons}}\label{coherent_mean_photons}

\texttt{coherent\_mean\_photons} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coherent\_mean\_photons $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coherent\_mean\_photons |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cohomology\_rank}}{cohomology\_rank}}\label{cohomology_rank}

\texttt{cohomology\_rank} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cohomology\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cohomology\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coif1\_coeffs}}{coif1\_coeffs}}\label{coif1_coeffs}

\texttt{coif1\_coeffs} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coif1\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coif1\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coiflet\_wavelet\_step}}{coiflet\_wavelet\_step}}\label{coiflet_wavelet_step}

\texttt{coiflet\_wavelet\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coiflet\_wavelet\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coiflet\_wavelet\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coin\_flip}}{coin\_flip}}\label{coin_flip}

\texttt{coin\_flip} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coin\_flip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coin\_flip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cointegration\_eg}}{cointegration\_eg}}\label{cointegration_eg}

\texttt{cointegration\_eg} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cointegration\_eg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cointegration\_eg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cointegration\_residual}}{cointegration\_residual}}\label{cointegration_residual}

\texttt{cointegration\_residual} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cointegration\_residual $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cointegration\_residual |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{colMeans}}{colMeans}}\label{colmeans}

\texttt{col\_means} (alias \texttt{colMeans}) --- mean of each column.
Like R\textquotesingle s colMeans().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p colMeans([[2,4],[6,8]])  \# [4, 6]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{colSums}}{colSums}}\label{colsums}

\texttt{col\_sums} (alias \texttt{colSums}) --- sum of each column. Like
R\textquotesingle s colSums().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p colSums([[1,2],[3,4]])  \# [4, 6]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cole\_cole\_eis}}{cole\_cole\_eis}}\label{cole_cole_eis}

\texttt{cole\_cole\_eis} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cole\_cole\_eis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cole\_cole\_eis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collapse\_whitespace}}{collapse\_whitespace}}\label{collapse_whitespace}

\texttt{collapse\_whitespace} --- string processing (uncategorized
batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collapse\_whitespace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collapse\_whitespace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collatz}}{collatz}}\label{collatz}

\texttt{collatz} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{collatz\_length}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collatz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collatz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collatz\_length}}{collatz\_length}}\label{collatz_length}

\texttt{collatz\_length} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collatz\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collatz\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collatz\_sequence}}{collatz\_sequence}}\label{collatz_sequence}

\texttt{collatz\_sequence} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collatz\_sequence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collatz\_sequence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collatzseq}}{collatzseq}}\label{collatzseq}

\texttt{collatzseq} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{collatz\_sequence}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collatzseq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collatzseq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collusion\_payoff\_step}}{collusion\_payoff\_step}}\label{collusion_payoff_step}

\texttt{collusion\_payoff\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collusion\_payoff\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collusion\_payoff\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{collws}}{collws}}\label{collws}

\texttt{collws} --- string processing (uncategorized batch) builtin.
Alias for \texttt{collapse\_whitespace}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = collws $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map collws |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color256}}{color256}}\label{color256}

\texttt{color256} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_blend}}{color\_blend}}\label{color_blend}

\texttt{color\_blend} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_blend $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_blend |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_blend\_alpha}}{color\_blend\_alpha}}\label{color_blend_alpha}

\texttt{color\_blend\_alpha} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_blend\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_blend\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_blend\_t}}{color\_blend\_t}}\label{color_blend_t}

\texttt{color\_blend\_t} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_blend\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_blend\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_complement}}{color\_complement}}\label{color_complement}

\texttt{color\_complement} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_complement $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_complement |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_darken}}{color\_darken}}\label{color_darken}

\texttt{color\_darken} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_darken $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_darken |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_distance}}{color\_distance}}\label{color_distance}

\texttt{color\_distance} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_grayscale}}{color\_grayscale}}\label{color_grayscale}

\texttt{color\_grayscale} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_grayscale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_grayscale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_invert}}{color\_invert}}\label{color_invert}

\texttt{color\_invert} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_invert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_invert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_lighten}}{color\_lighten}}\label{color_lighten}

\texttt{color\_lighten} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_lighten $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_lighten |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{color\_temperature\_kelvin}}{color\_temperature\_kelvin}}\label{color_temperature_kelvin}

\texttt{color\_temperature\_kelvin} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = color\_temperature\_kelvin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map color\_temperature\_kelvin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{columbic\_capacity\_lihalfcell}}{columbic\_capacity\_lihalfcell}}\label{columbic_capacity_lihalfcell}

\texttt{columbic\_capacity\_lihalfcell} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = columbic\_capacity\_lihalfcell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map columbic\_capacity\_lihalfcell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{column\_generation\_step}}{column\_generation\_step}}\label{column_generation_step}

\texttt{column\_generation\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = column\_generation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map column\_generation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{comb}}{comb}}\label{comb}

\texttt{combinations(\$n,\ \$r)} (alias \texttt{comb}) --- number of
ways to choose r items from n. Formula: n!/(r!(n-r)!). Order
doesn\textquotesingle t matter.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p comb(5, 3)    \# 10 (ways to choose 3 items from 5)}
\NormalTok{p comb(52, 5)   \# 2598960 (poker hands)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{combinations\_rep}}{combinations\_rep}}\label{combinations_rep}

\texttt{combinations\_rep} --- additional missing stdlib functions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = combinations\_rep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map combinations\_rep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{combinatorial\_auction\_step}}{combinatorial\_auction\_step}}\label{combinatorial_auction_step}

\texttt{combinatorial\_auction\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = combinatorial\_auction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map combinatorial\_auction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{combrep}}{combrep}}\label{combrep}

\texttt{combrep} --- additional missing stdlib functions builtin. Alias
for \texttt{combinations\_rep}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = combrep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map combrep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{common\_kmers}}{common\_kmers}}\label{common_kmers}

\texttt{common\_kmers} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = common\_kmers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map common\_kmers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{common\_knowledge\_iterations}}{common\_knowledge\_iterations}}\label{common_knowledge_iterations}

\texttt{common\_knowledge\_iterations} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = common\_knowledge\_iterations $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map common\_knowledge\_iterations |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{common\_prefix}}{common\_prefix}}\label{common_prefix}

\texttt{common\_prefix} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = common\_prefix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map common\_prefix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{common\_suffix}}{common\_suffix}}\label{common_suffix}

\texttt{common\_suffix} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = common\_suffix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map common\_suffix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{comoving\_distance}}{comoving\_distance}}\label{comoving_distance}

\texttt{comoving\_distance} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = comoving\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map comoving\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{comoving\_distance\_approx}}{comoving\_distance\_approx}}\label{comoving_distance_approx}

\texttt{comoving\_distance\_approx} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = comoving\_distance\_approx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map comoving\_distance\_approx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compare\_versions}}{compare\_versions}}\label{compare_versions}

\texttt{compare\_versions} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compare\_versions $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compare\_versions |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{composition\_count}}{composition\_count}}\label{composition_count}

\texttt{composition\_count} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = composition\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map composition\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compound\_interest}}{compound\_interest}}\label{compound_interest}

\texttt{compound\_interest} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compound\_interest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compound\_interest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compound\_interest\_periods}}{compound\_interest\_periods}}\label{compound_interest_periods}

\texttt{compound\_interest\_periods} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compound\_interest\_periods $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compound\_interest\_periods |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compress}}{compress}}\label{compress}

\texttt{compress} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compress $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compress |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compressibility\_z}}{compressibility\_z}}\label{compressibility_z}

\texttt{compressibility\_z} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compressibility\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compressibility\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compton\_wavelength}}{compton\_wavelength}}\label{compton_wavelength}

\texttt{compton\_wavelength} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compton\_wavelength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compton\_wavelength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{compute\_residuals}}{compute\_residuals}}\label{compute_residuals}

\texttt{compute\_residuals} --- batch 9 builtin. Alias for
\texttt{residuals\_compute}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = compute\_residuals $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map compute\_residuals |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{concat\_map}}{concat\_map}}\label{concat_map}

\texttt{concat\_map} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = concat\_map $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map concat\_map |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{concentration\_dilute}}{concentration\_dilute}}\label{concentration_dilute}

\texttt{concentration\_dilute} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = concentration\_dilute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map concentration\_dilute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{concordance\_correlation}}{concordance\_correlation}}\label{concordance_correlation}

\texttt{concordance\_correlation} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = concordance\_correlation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map concordance\_correlation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cond}}{cond}}\label{cond}

\texttt{matrix\_cond} (aliases \texttt{mcond}, \texttt{cond}) estimates
the condition number of a matrix (ratio of largest to smallest singular
value). Large values indicate ill-conditioning.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cond([[1,0],[0,1]])    \# 1 (perfect)}
\NormalTok{p cond([[1,2],[2,4]])    \# Inf (singular)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{conditional\_entropy\_step}}{conditional\_entropy\_step}}\label{conditional_entropy_step}

\texttt{conditional\_entropy\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = conditional\_entropy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map conditional\_entropy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{conditional\_gradient\_step}}{conditional\_gradient\_step}}\label{conditional_gradient_step}

\texttt{conditional\_gradient\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = conditional\_gradient\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map conditional\_gradient\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{condorcet\_winner\_check}}{condorcet\_winner\_check}}\label{condorcet_winner_check}

\texttt{condorcet\_winner\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = condorcet\_winner\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map condorcet\_winner\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cone\_surface}}{cone\_surface}}\label{cone_surface}

\texttt{cone\_surface} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cone\_surface $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cone\_surface |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cone\_volume}}{cone\_volume}}\label{cone_volume}

\texttt{cone\_volume} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cone\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cone\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{conevol}}{conevol}}\label{conevol}

\texttt{conevol} --- geometry / physics builtin. Alias for
\texttt{cone\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = conevol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map conevol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{confint}}{confint}}\label{confint}

\texttt{confint\_lm} (alias \texttt{confint}) --- confidence intervals
for model coefficients. Returns hash with intercept\_lower/upper,
slope\_lower/upper.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ci = confint(lm([1,2,3,4,5], [2,4,5,4,5]))}
\NormalTok{p $ci{-}\textgreater{}\{slope\_lower\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{conformal\_compactification\_step}}{conformal\_compactification\_step}}\label{conformal_compactification_step}

\texttt{conformal\_compactification\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = conformal\_compactification\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map conformal\_compactification\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{confusion\_counts}}{confusion\_counts}}\label{confusion_counts}

\texttt{confusion\_counts} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = confusion\_counts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map confusion\_counts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{conj}}{conj}}\label{conj}

\texttt{conj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = conj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map conj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{connected\_components}}{connected\_components}}\label{connected_components}

\texttt{connected\_components} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = connected\_components $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map connected\_components |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{connected\_components\_graph}}{connected\_components\_graph}}\label{connected_components_graph}

\texttt{connected\_components\_graph} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = connected\_components\_graph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map connected\_components\_graph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cons}}{cons}}\label{cons}

\texttt{cons} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cons $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cons |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{consecutive\_eq}}{consecutive\_eq}}\label{consecutive_eq}

\texttt{consecutive\_eq} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = consecutive\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map consecutive\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{consecutive\_pairs}}{consecutive\_pairs}}\label{consecutive_pairs}

\texttt{consecutive\_pairs} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = consecutive\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map consecutive\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{const\_fn}}{const\_fn}}\label{const_fn}

\texttt{const\_fn} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = const\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map const\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{constant\_case}}{constant\_case}}\label{constant_case}

\texttt{constant\_case} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = constant\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map constant\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{constituency\_cyk}}{constituency\_cyk}}\label{constituency_cyk}

\texttt{constituency\_cyk} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = constituency\_cyk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map constituency\_cyk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{consumer\_surplus}}{consumer\_surplus}}\label{consumer_surplus}

\texttt{consumer\_surplus} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = consumer\_surplus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map consumer\_surplus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contact\_tracing\_eff}}{contact\_tracing\_eff}}\label{contact_tracing_eff}

\texttt{contact\_tracing\_eff} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contact\_tracing\_eff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contact\_tracing\_eff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contains}}{contains}}\label{contains}

\texttt{contains} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contains $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contains |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contains\_all}}{contains\_all}}\label{contains_all}

\texttt{contains\_all} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contains\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contains\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contains\_any}}{contains\_any}}\label{contains_any}

\texttt{contains\_any} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contains\_any $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contains\_any |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contains\_elem}}{contains\_elem}}\label{contains_elem}

\texttt{contains\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contains\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contains\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contcomp}}{contcomp}}\label{contcomp}

\texttt{contcomp} --- finance (extended) builtin. Alias for
\texttt{continuous\_compound}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contcomp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contcomp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{content\_negotiate}}{content\_negotiate}}\label{content_negotiate}

\texttt{content\_negotiate} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = content\_negotiate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map content\_negotiate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{continued\_fraction\_sqrt}}{continued\_fraction\_sqrt}}\label{continued_fraction_sqrt}

\texttt{continued\_fraction\_sqrt} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = continued\_fraction\_sqrt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map continued\_fraction\_sqrt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{continuous\_compound}}{continuous\_compound}}\label{continuous_compound}

\texttt{continuous\_compound(\$principal,\ \$rate,\ \$time)} (alias
\texttt{ccomp}) --- computes future value with continuous compounding: P
× e\^{}(rt).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ccomp(1000, 0.05, 10)   \# \textasciitilde{}1648.72}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contrast\_ratio}}{contrast\_ratio}}\label{contrast_ratio}

\texttt{contrast\_ratio} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contrast\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contrast\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{contrast\_ratio\_wcag}}{contrast\_ratio\_wcag}}\label{contrast_ratio_wcag}

\texttt{contrast\_ratio\_wcag} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = contrast\_ratio\_wcag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map contrast\_ratio\_wcag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{conv}}{conv}}\label{conv}

\texttt{conv} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{convolution}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = conv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map conv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{converge}}{converge}}\label{converge}

\texttt{converge} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = converge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map converge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convex\_hull\_chan}}{convex\_hull\_chan}}\label{convex_hull_chan}

\texttt{convex\_hull\_chan} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convex\_hull\_chan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convex\_hull\_chan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convex\_hull\_jarvis}}{convex\_hull\_jarvis}}\label{convex_hull_jarvis}

\texttt{convex\_hull\_jarvis} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convex\_hull\_jarvis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convex\_hull\_jarvis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convexity}}{convexity}}\label{convexity}

\texttt{convexity} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convexity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convexity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convolution}}{convolution}}\label{convolution}

\texttt{convolution} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convolution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convolution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convolve\_2d}}{convolve\_2d}}\label{convolve_2d}

\texttt{convolve\_2d} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convolve\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convolve\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convolve\_full}}{convolve\_full}}\label{convolve_full}

\texttt{convolve\_full} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convolve\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convolve\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{convolve\_valid}}{convolve\_valid}}\label{convolve_valid}

\texttt{convolve\_valid} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = convolve\_valid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map convolve\_valid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coombs\_runoff\_step}}{coombs\_runoff\_step}}\label{coombs_runoff_step}

\texttt{coombs\_runoff\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coombs\_runoff\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coombs\_runoff\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cooperative\_game\_value}}{cooperative\_game\_value}}\label{cooperative_game_value}

\texttt{cooperative\_game\_value} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cooperative\_game\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cooperative\_game\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coordination\_game\_payoff}}{coordination\_game\_payoff}}\label{coordination_game_payoff}

\texttt{coordination\_game\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coordination\_game\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coordination\_game\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{copeland\_score\_step}}{copeland\_score\_step}}\label{copeland_score_step}

\texttt{copeland\_score\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = copeland\_score\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map copeland\_score\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coppersmith\_bound}}{coppersmith\_bound}}\label{coppersmith_bound}

\texttt{coppersmith\_bound} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coppersmith\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coppersmith\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coptic\_from\_fixed}}{coptic\_from\_fixed}}\label{coptic_from_fixed}

\texttt{coptic\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coptic\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coptic\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{copy\_sign}}{copy\_sign}}\label{copy_sign}

\texttt{copy\_sign} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = copy\_sign $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map copy\_sign |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{copy\_within}}{copy\_within}}\label{copy_within}

\texttt{copy\_within} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = copy\_within $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map copy\_within |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{copysign}}{copysign}}\label{copysign}

\texttt{copysign} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = copysign $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map copysign |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coq\_tactic\_apply}}{coq\_tactic\_apply}}\label{coq_tactic_apply}

\texttt{coq\_tactic\_apply} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coq\_tactic\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coq\_tactic\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coq\_unify\_term}}{coq\_unify\_term}}\label{coq_unify_term}

\texttt{coq\_unify\_term} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coq\_unify\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coq\_unify\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cor\_mat}}{cor\_mat}}\label{cor_mat}

\texttt{cor\_matrix} (alias \texttt{cor\_mat}) --- correlation matrix
from observations. Each row is an observation vector.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $R = cor\_mat([[1,2],[3,4],[5,6]])  \# 2x2 correlation matrix}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{core\_coalition}}{core\_coalition}}\label{core_coalition}

\texttt{core\_coalition} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = core\_coalition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map core\_coalition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{core\_membership\_check}}{core\_membership\_check}}\label{core_membership_check}

\texttt{core\_membership\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = core\_membership\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map core\_membership\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coreference\_singleton}}{coreference\_singleton}}\label{coreference_singleton}

\texttt{coreference\_singleton} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coreference\_singleton $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coreference\_singleton |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{corner\_subpix}}{corner\_subpix}}\label{corner_subpix}

\texttt{corner\_subpix} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = corner\_subpix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map corner\_subpix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{corr}}{corr}}\label{corr}

\texttt{corr} --- extended stdlib builtin. Alias for
\texttt{correlation}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = corr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map corr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{corr\_agg}}{corr\_agg}}\label{corr_agg}

\texttt{corr\_agg} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = corr\_agg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map corr\_agg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{correlate\_full}}{correlate\_full}}\label{correlate_full}

\texttt{correlate\_full} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = correlate\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map correlate\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{correlated\_equilibrium\_value}}{correlated\_equilibrium\_value}}\label{correlated_equilibrium_value}

\texttt{correlated\_equilibrium\_value} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = correlated\_equilibrium\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map correlated\_equilibrium\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{correlation}}{correlation}}\label{correlation}

\texttt{correlation} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = correlation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map correlation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{corsi\_for}}{corsi\_for}}\label{corsi_for}

\texttt{corsi\_for} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = corsi\_for $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map corsi\_for |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosh}}{cosh}}\label{cosh}

\texttt{cosh} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosh\_minus1\_over\_x2}}{cosh\_minus1\_over\_x2}}\label{cosh_minus1_over_x2}

\texttt{cosh\_minus1\_over\_x2} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosh\_minus1\_over\_x2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosh\_minus1\_over\_x2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosine\_integral\_ci}}{cosine\_integral\_ci}}\label{cosine_integral_ci}

\texttt{cosine\_integral\_ci} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosine\_integral\_ci $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosine\_integral\_ci |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosine\_similarity}}{cosine\_similarity}}\label{cosine_similarity}

\texttt{cosine\_similarity} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosine\_similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosine\_similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosmic\_distance\_modulus\_si}}{cosmic\_distance\_modulus\_si}}\label{cosmic_distance_modulus_si}

\texttt{cosmic\_distance\_modulus\_si} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosmic\_distance\_modulus\_si $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosmic\_distance\_modulus\_si |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosmological\_constant}}{cosmological\_constant}}\label{cosmological_constant}

\texttt{cosmological\_constant} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosmological\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosmological\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cosmological\_constant\_term}}{cosmological\_constant\_term}}\label{cosmological_constant_term}

\texttt{cosmological\_constant\_term} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cosmological\_constant\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cosmological\_constant\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cot}}{cot}}\label{cot}

\texttt{cot} returns the cotangent (1/tan) of an angle in radians.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cot(0.7854)  \# ≈ 1.0 (cot 45°)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coulomb}}{coulomb}}\label{coulomb}

\texttt{coulomb\_force(\$q1,\ \$q2,\ \$r)} (alias \texttt{coulomb}) ---
Coulomb\textquotesingle s law: F = kq₁q₂/r². Charges in Coulombs,
distance in meters.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p coulomb(1e{-}6, 1e{-}6, 0.1)   \# \textasciitilde{}0.9 N (two 1μC charges 10cm apart)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coulomb\_constant}}{coulomb\_constant}}\label{coulomb_constant}

\texttt{coulomb\_constant} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coulomb\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coulomb\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coulomb\_f0}}{coulomb\_f0}}\label{coulomb_f0}

\texttt{coulomb\_f0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coulomb\_f0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coulomb\_f0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coulombic\_efficiency\_cell}}{coulombic\_efficiency\_cell}}\label{coulombic_efficiency_cell}

\texttt{coulombic\_efficiency\_cell} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coulombic\_efficiency\_cell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coulombic\_efficiency\_cell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_by}}{count\_by}}\label{count_by}

\texttt{count\_by} --- functional / iterator builtin. Alias for
\texttt{take\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_bytes}}{count\_bytes}}\label{count_bytes}

\texttt{count\_bytes} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_bytes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_bytes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_char}}{count\_char}}\label{count_char}

\texttt{count\_char} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_char $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_char |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_chars}}{count\_chars}}\label{count_chars}

\texttt{count\_chars} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_consonants}}{count\_consonants}}\label{count_consonants}

\texttt{count\_consonants} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_consonants $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_consonants |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_digits}}{count\_digits}}\label{count_digits}

\texttt{count\_digits} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_digits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_digits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_elem}}{count\_elem}}\label{count_elem}

\texttt{count\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_eq}}{count\_eq}}\label{count_eq}

\texttt{count\_eq} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_inversions}}{count\_inversions}}\label{count_inversions}

\texttt{count\_inversions} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_inversions $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_inversions |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_letters}}{count\_letters}}\label{count_letters}

\texttt{count\_letters} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_letters $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_letters |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_lines}}{count\_lines}}\label{count_lines}

\texttt{count\_lines} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_lines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_lines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_lower}}{count\_lower}}\label{count_lower}

\texttt{count\_lower} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_match}}{count\_match}}\label{count_match}

\texttt{count\_match} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_ne}}{count\_ne}}\label{count_ne}

\texttt{count\_ne} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_ne $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_ne |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_punctuation}}{count\_punctuation}}\label{count_punctuation}

\texttt{count\_punctuation} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_punctuation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_punctuation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_regex\_matches}}{count\_regex\_matches}}\label{count_regex_matches}

\texttt{count\_regex\_matches} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_regex\_matches $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_regex\_matches |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_spaces}}{count\_spaces}}\label{count_spaces}

\texttt{count\_spaces} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_spaces $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_spaces |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_substring}}{count\_substring}}\label{count_substring}

\texttt{count\_substring} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_substring $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_substring |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_upper}}{count\_upper}}\label{count_upper}

\texttt{count\_upper} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_upper $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_upper |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_vowels}}{count\_vowels}}\label{count_vowels}

\texttt{count\_vowels} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_vowels $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_vowels |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_while}}{count\_while}}\label{count_while}

\texttt{count\_while} --- ruby enumerable extras builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_while $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_while |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{count\_words}}{count\_words}}\label{count_words}

\texttt{count\_words} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = count\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map count\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{counter}}{counter}}\label{counter}

\texttt{counter} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = counter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map counter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{counter\_most\_common}}{counter\_most\_common}}\label{counter_most_common}

\texttt{counter\_most\_common} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = counter\_most\_common $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map counter\_most\_common |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{countif}}{countif}}\label{countif}

\texttt{countif} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = countif $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map countif |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{countifs}}{countifs}}\label{countifs}

\texttt{countifs} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = countifs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map countifs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{coupon\_count}}{coupon\_count}}\label{coupon_count}

\texttt{coupon\_count} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = coupon\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map coupon\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{courant\_friedrichs\_lewy}}{courant\_friedrichs\_lewy}}\label{courant_friedrichs_lewy}

\texttt{courant\_friedrichs\_lewy} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = courant\_friedrichs\_lewy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map courant\_friedrichs\_lewy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cournot\_eq}}{cournot\_eq}}\label{cournot_eq}

\texttt{cournot\_eq} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cournot\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cournot\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cournot\_quantity\_step}}{cournot\_quantity\_step}}\label{cournot_quantity_step}

\texttt{cournot\_quantity\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cournot\_quantity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cournot\_quantity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cov}}{cov}}\label{cov}

\texttt{cov} --- extended stdlib builtin. Alias for \texttt{covariance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cov $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cov |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cov2cor}}{cov2cor}}\label{cov2cor}

\texttt{cov2cor} --- convert covariance matrix to correlation matrix.
Like R\textquotesingle s cov2cor().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cor = cov2cor(cov\_mat($data))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cov\_mat}}{cov\_mat}}\label{cov_mat}

\texttt{cov\_matrix} (alias \texttt{cov\_mat}) --- covariance matrix
from observations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $S = cov\_mat([[1,2],[3,4],[5,6]])}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{covar\_pop}}{covar\_pop}}\label{covar_pop}

\texttt{covar\_pop} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = covar\_pop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map covar\_pop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{covar\_samp}}{covar\_samp}}\label{covar_samp}

\texttt{covar\_samp} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = covar\_samp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map covar\_samp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{covariance}}{covariance}}\label{covariance}

\texttt{covariance} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = covariance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map covariance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{covariance\_matrix\_pts}}{covariance\_matrix\_pts}}\label{covariance_matrix_pts}

\texttt{covariance\_matrix\_pts} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = covariance\_matrix\_pts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map covariance\_matrix\_pts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{covariant\_derivative\_step}}{covariant\_derivative\_step}}\label{covariant_derivative_step}

\texttt{covariant\_derivative\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = covariant\_derivative\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map covariant\_derivative\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cp\_monatomic\_ideal}}{cp\_monatomic\_ideal}}\label{cp_monatomic_ideal}

\texttt{cp\_monatomic\_ideal} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cp\_monatomic\_ideal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cp\_monatomic\_ideal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cpat}}{cpat}}\label{cpat}

\texttt{cpat} --- extended stdlib builtin. Alias for
\texttt{code\_point\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cpat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cpat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cpfx}}{cpfx}}\label{cpfx}

\texttt{cpfx} --- extended stdlib builtin. Alias for
\texttt{common\_prefix}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cpfx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cpfx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cpl\_w}}{cpl\_w}}\label{cpl_w}

\texttt{cpl\_w} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cpl\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cpl\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cprod}}{cprod}}\label{cprod}

\texttt{cprod} --- python/ruby stdlib builtin. Alias for
\texttt{cartesian\_product}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cprod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cprod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cprod\_acc}}{cprod\_acc}}\label{cprod_acc}

\texttt{cprod\_acc} --- extended stdlib builtin. Alias for
\texttt{cumprod}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cprod\_acc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cprod\_acc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cpsgn}}{cpsgn}}\label{cpsgn}

\texttt{cpsgn} --- extended stdlib builtin. Alias for
\texttt{copy\_sign}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cpsgn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cpsgn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cpu\_count}}{cpu\_count}}\label{cpu_count}

\texttt{cpu\_count} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cpu\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cpu\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cpyw}}{cpyw}}\label{cpyw}

\texttt{cpyw} --- additional missing stdlib functions builtin. Alias for
\texttt{copy\_within}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cpyw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cpyw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cr}}{cr}}\label{cr}

\texttt{cr} --- data / network builtin. Alias for \texttt{csv\_read}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cramer\_lundberg\_step}}{cramer\_lundberg\_step}}\label{cramer_lundberg_step}

\texttt{cramer\_lundberg\_step} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cramer\_lundberg\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cramer\_lundberg\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cramer\_rao\_bound}}{cramer\_rao\_bound}}\label{cramer_rao_bound}

\texttt{cramer\_rao\_bound} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cramer\_rao\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cramer\_rao\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crank\_nicolson\_ode}}{crank\_nicolson\_ode}}\label{crank_nicolson_ode}

\texttt{crank\_nicolson\_ode} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crank\_nicolson\_ode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crank\_nicolson\_ode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crc16\_ccitt}}{crc16\_ccitt}}\label{crc16_ccitt}

\texttt{crc16\_ccitt} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crc16\_ccitt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crc16\_ccitt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{credibility\_buhlmann}}{credibility\_buhlmann}}\label{credibility_buhlmann}

\texttt{credibility\_buhlmann} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = credibility\_buhlmann $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map credibility\_buhlmann |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crf\_log\_likelihood}}{crf\_log\_likelihood}}\label{crf_log_likelihood}

\texttt{crf\_log\_likelihood} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crf\_log\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crf\_log\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crindex}}{crindex}}\label{crindex}

\texttt{crindex\ STRING,\ SUBSTRING\ {[},\ FROM{]}} ---
codepoint-indexed equivalent of Perl 5\textquotesingle s
\texttt{rindex}. Returns the last codepoint position where SUBSTRING
occurs (at or before FROM, defaulting to end-of-string), or -1 on miss.
Counterpart to \texttt{cindex}; pairs with \texttt{{[}{]}} slice
operators and \texttt{len}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $path = "foo/bar/─/baz.gz"}
\NormalTok{p rindex  $path, "/"        \# 13 (bytes)}
\NormalTok{p crindex $path, "/"        \# 11 (codepoints)}
\NormalTok{my $i = crindex $path, "/"}
\NormalTok{p $path[$i + 1 : len($path) {-} 1]   \# "baz.gz"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{critang}}{critang}}\label{critang}

\texttt{critang} --- physics formulas builtin. Alias for
\texttt{critical\_angle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = critang $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map critang |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{critical\_angle}}{critical\_angle}}\label{critical_angle}

\texttt{critical\_angle} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = critical\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map critical\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{critical\_density}}{critical\_density}}\label{critical_density}

\texttt{critical\_density} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = critical\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map critical\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{critical\_density\_si}}{critical\_density\_si}}\label{critical_density_si}

\texttt{critical\_density\_si} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = critical\_density\_si $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map critical\_density\_si |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cron\_next\_fire}}{cron\_next\_fire}}\label{cron_next_fire}

\texttt{cron\_next\_fire} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cron\_next\_fire $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cron\_next\_fire |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cross\_correlation}}{cross\_correlation}}\label{cross_correlation}

\texttt{cross\_correlation(\textbackslash{}@a,\ \textbackslash{}@b)}
(alias \texttt{xcorr}) --- computes the cross-correlation of two
signals. Measures similarity as a function of time-lag. Peak location
indicates time delay between signals.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $xcor = xcorr(\textbackslash{}@signal1, \textbackslash{}@signal2)}
\NormalTok{my $lag = max\_index(@$xcor)   \# find peak lag}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cross\_elasticity}}{cross\_elasticity}}\label{cross_elasticity}

\texttt{cross\_elasticity} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cross\_elasticity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cross\_elasticity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cross\_entropy}}{cross\_entropy}}\label{cross_entropy}

\texttt{cross\_entropy} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cross\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cross\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cross\_polarization\_amp}}{cross\_polarization\_amp}}\label{cross_polarization_amp}

\texttt{cross\_polarization\_amp} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cross\_polarization\_amp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cross\_polarization\_amp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cross\_product}}{cross\_product}}\label{cross_product}

\texttt{cross\_product} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cross\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cross\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crossp}}{crossp}}\label{crossp}

\texttt{crossp} --- extended stdlib builtin. Alias for
\texttt{cross\_product}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crossp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crossp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crossprod}}{crossprod}}\label{crossprod}

\texttt{crossprod} --- cross product t(M) * M (R\textquotesingle s
crossprod). Efficiently computes M\^{}T M without explicit transpose.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $ata = crossprod([[1,2],[3,4]])  \# [[10,14],[14,20]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crr\_american\_call}}{crr\_american\_call}}\label{crr_american_call}

\texttt{crr\_american\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crr\_american\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crr\_american\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crr\_american\_put}}{crr\_american\_put}}\label{crr_american_put}

\texttt{crr\_american\_put} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crr\_american\_put $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crr\_american\_put |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crustal\_density\_depth}}{crustal\_density\_depth}}\label{crustal_density_depth}

\texttt{crustal\_density\_depth} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crustal\_density\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crustal\_density\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{crystal\_field\_ligand}}{crystal\_field\_ligand}}\label{crystal_field_ligand}

\texttt{crystal\_field\_ligand} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = crystal\_field\_ligand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map crystal\_field\_ligand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csc}}{csc}}\label{csc}

\texttt{csc} returns the cosecant (1/sin) of an angle in radians.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p csc(1.5708)  \# ≈ 1.0 (csc 90°)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csd\_xy}}{csd\_xy}}\label{csd_xy}

\texttt{csd\_xy} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = csd\_xy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map csd\_xy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csfx}}{csfx}}\label{csfx}

\texttt{csfx} --- extended stdlib builtin. Alias for
\texttt{common\_suffix}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = csfx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map csfx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csiszar\_phi\_div}}{csiszar\_phi\_div}}\label{csiszar_phi_div}

\texttt{csiszar\_phi\_div} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = csiszar\_phi\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map csiszar\_phi\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cspline}}{cspline}}\label{cspline}

\texttt{cubic\_spline} (aliases \texttt{cspline}, \texttt{spline})
performs natural cubic spline interpolation. Takes xs, ys, and a query
point x.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p spline([0,1,2,3], [0,1,0,1], 1.5)  \# smooth interpolation}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{csum}}{csum}}\label{csum}

\texttt{csum} --- extended stdlib builtin. Alias for \texttt{cumsum}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = csum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map csum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cswap\_gate}}{cswap\_gate}}\label{cswap_gate}

\texttt{cswap\_gate} --- batches 14-16 builtin. Alias for
\texttt{fredkin\_gate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cswap\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cswap\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ctime}}{ctime}}\label{ctime}

\texttt{ctime} --- file stat / path builtin. Alias for
\texttt{file\_ctime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ctime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ctime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ctxt}}{ctxt}}\label{ctxt}

\texttt{ctxt} --- extended stdlib builtin. Alias for
\texttt{center\_text}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ctxt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ctxt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cuban\_number}}{cuban\_number}}\label{cuban_number}

\texttt{cuban\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cuban\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cuban\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cube\_fn}}{cube\_fn}}\label{cube_fn}

\texttt{cube\_fn} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cube\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cube\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cube\_root}}{cube\_root}}\label{cube_root}

\texttt{cube\_root} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cube\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cube\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cubes\_seq}}{cubes\_seq}}\label{cubes_seq}

\texttt{cubes\_seq} --- sequences builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cubes\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cubes\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cullen\_number}}{cullen\_number}}\label{cullen_number}

\texttt{cullen\_number} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cullen\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cullen\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cumipmt}}{cumipmt}}\label{cumipmt}

\texttt{cumipmt} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cumipmt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cumipmt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cummax}}{cummax}}\label{cummax}

\texttt{cummax} --- cumulative maximum. Each element is the max of all
elements up to that position.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cummax([3,1,4,1,5,9])  \# [3,3,4,4,5,9]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cummin}}{cummin}}\label{cummin}

\texttt{cummin} --- cumulative minimum.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cummin([9,5,1,4,3])  \# [9,5,1,1,1]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cumprinc}}{cumprinc}}\label{cumprinc}

\texttt{cumprinc} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cumprinc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cumprinc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cumprod}}{cumprod}}\label{cumprod}

\texttt{cumprod} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cumprod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cumprod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cumsum}}{cumsum}}\label{cumsum}

\texttt{cumsum} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cumsum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cumsum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cumtrapz}}{cumtrapz}}\label{cumtrapz}

\texttt{cumtrapz} cumulative trapezoidal integration. Returns running
integral array.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @y = (1, 2, 3, 4)}
\NormalTok{my @F = @\{cumtrapz(\textbackslash{}@y)\}  \# [0, 1.5, 4.0, 7.5]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cups\_to\_ml}}{cups\_to\_ml}}\label{cups_to_ml}

\texttt{cups\_to\_ml} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cups\_to\_ml $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{current\_divider}}{current\_divider}}\label{current_divider}

\texttt{current\_divider} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = current\_divider $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map current\_divider |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{curve25519\_mul\_simple}}{curve25519\_mul\_simple}}\label{curve25519_mul_simple}

\texttt{curve25519\_mul\_simple} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = curve25519\_mul\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map curve25519\_mul\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cusip\_check}}{cusip\_check}}\label{cusip_check}

\texttt{cusip\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cusip\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cusip\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cut}}{cut}}\label{cut}

\texttt{cut} --- bin continuous values into intervals. Returns integer
bin indices. Like R\textquotesingle s cut().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cut([1.5, 3.2, 7.8], [0, 2, 5, 10])  \# [1, 2, 3]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cutree}}{cutree}}\label{cutree}

\texttt{cutree} --- cut a dendrogram into k clusters. Takes merge list
from hclust and k. Returns cluster assignments. Like R\textquotesingle s
cutree().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @clusters = @\{cutree(hclust(dist\_mat($data)), 3)\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cutting\_plane\_step}}{cutting\_plane\_step}}\label{cutting_plane_step}

\texttt{cutting\_plane\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cutting\_plane\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cutting\_plane\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cv}}{cv}}\label{cv}

\texttt{cv} --- math / numeric (uncategorized batch) builtin. Alias for
\texttt{coeff\_of\_variation}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cv\_monatomic\_ideal}}{cv\_monatomic\_ideal}}\label{cv_monatomic_ideal}

\texttt{cv\_monatomic\_ideal} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cv\_monatomic\_ideal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cv\_monatomic\_ideal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cvar\_historical}}{cvar\_historical}}\label{cvar_historical}

\texttt{cvar\_historical} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cvar\_historical $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cvar\_historical |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cw}}{cw}}\label{cw}

\texttt{cw} --- data / network builtin. Alias for \texttt{csv\_write}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cwd}}{cwd}}\label{cwd}

\texttt{cwd} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cwd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cwd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cwt\_morlet}}{cwt\_morlet}}\label{cwt_morlet}

\texttt{cwt\_morlet} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cwt\_morlet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cwt\_morlet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyan}}{cyan}}\label{cyan}

\texttt{cyan} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cyan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cyan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyan\_bold}}{cyan\_bold}}\label{cyan_bold}

\texttt{cyan\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cyan\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cyan\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_banner}}{cyber\_banner}}\label{cyber_banner}

\texttt{cyber\_banner} (alias \texttt{neon\_banner}) --- large neon
block-letter banner with gradient coloring and border. Args: text.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_banner("STRYKE")}
\NormalTok{p cyber\_banner("HACK THE PLANET")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_circuit}}{cyber\_circuit}}\label{cyber_circuit}

\texttt{cyber\_circuit} --- circuit board pattern with traces,
intersections, and glowing nodes. Args: {[}width, height, seed{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_circuit()             \# 60x20 default}
\NormalTok{p cyber\_circuit(80, 30, 42)   \# custom}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_city}}{cyber\_city}}\label{cyber_city}

\texttt{cyber\_city} --- procedural neon cityscape with buildings,
windows, stars, and antennas. Args: {[}width, height, seed{]}. Output:
ANSI-colored string for terminal.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_city()              \# 80x24 default}
\NormalTok{p cyber\_city(120, 40, 99)   \# custom size and seed}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_eye}}{cyber\_eye}}\label{cyber_eye}

\texttt{cyber\_eye} --- cyberpunk all-seeing eye motif with layered
glow. Args: {[}size{]}. Size: "small" (default) or "large".

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_eye()          \# small eye}
\NormalTok{p cyber\_eye("large")   \# large eye}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_glitch}}{cyber\_glitch}}\label{cyber_glitch}

\texttt{cyber\_glitch} (alias \texttt{glitch\_text}) --- glitch-distort
text with ANSI corruption, screen tears, and neon color bleeding. Args:
text {[}, intensity 1-10{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_glitch("SYSTEM BREACH", 7)}
\NormalTok{p cyber\_glitch("hello world")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_grid}}{cyber\_grid}}\label{cyber_grid}

\texttt{cyber\_grid} --- retro perspective grid with vanishing point and
neon glow (Tron/synthwave style). Args: {[}width, height{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_grid()           \# 80x24 default}
\NormalTok{p cyber\_grid(120, 30)    \# wider grid}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_rain}}{cyber\_rain}}\label{cyber_rain}

\texttt{cyber\_rain} (alias \texttt{matrix\_rain}) --- matrix-style
digital rain with Japanese katakana and green phosphor glow. Args:
{[}width, height, seed{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_rain()              \# 80x24 default}
\NormalTok{p cyber\_rain(120, 40, 42)   \# custom}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyber\_skull}}{cyber\_skull}}\label{cyber_skull}

\texttt{cyber\_skull} --- neon skull ASCII art with glitch effects.
Args: {[}size{]}. Size: "small" (default) or "large".

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p cyber\_skull()          \# small skull}
\NormalTok{p cyber\_skull("large")   \# large skull}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyc}}{cyc}}\label{cyc}

\texttt{cyc} --- algebraic match builtin. Alias for \texttt{cycle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cyc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cyc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cycle}}{cycle}}\label{cycle}

\texttt{cycle} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cycle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cycle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cycle\_n}}{cycle\_n}}\label{cycle_n}

\texttt{cycle\_n} --- collection (batch 2) builtin. Alias for
\texttt{repeat\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cycle\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cycle\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cyclic\_homology\_step}}{cyclic\_homology\_step}}\label{cyclic_homology_step}

\texttt{cyclic\_homology\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cyclic\_homology\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cyclic\_homology\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cylinder\_surface}}{cylinder\_surface}}\label{cylinder_surface}

\texttt{cylinder\_surface} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cylinder\_surface $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cylinder\_surface |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cylinder\_volume}}{cylinder\_volume}}\label{cylinder_volume}

\texttt{cylinder\_volume} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cylinder\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cylinder\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{cylvol}}{cylvol}}\label{cylvol}

\texttt{cylvol} --- geometry / physics builtin. Alias for
\texttt{cylinder\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = cylvol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map cylvol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{d}}{d}}\label{d}

\texttt{d} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{d2comp}}{d2comp}}\label{d2comp}

\texttt{d2comp} --- misc / utility builtin. Alias for
\texttt{degrees\_to\_compass}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = d2comp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map d2comp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{d2r}}{d2r}}\label{d2r}

\texttt{d2r} --- trivial numeric / predicate builtins builtin. Alias for
\texttt{deg\_to\_rad}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = d2r $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map d2r |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dB\_power}}{dB\_power}}\label{db_power}

\texttt{dB\_power} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dB\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dB\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dB\_voltage}}{dB\_voltage}}\label{db_voltage}

\texttt{dB\_voltage} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dB\_voltage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dB\_voltage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dagum\_pdf}}{dagum\_pdf}}\label{dagum_pdf}

\texttt{dagum\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dagum\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dagum\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{daitch\_mokotoff}}{daitch\_mokotoff}}\label{daitch_mokotoff}

\texttt{daitch\_mokotoff} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = daitch\_mokotoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map daitch\_mokotoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dalys\_disability\_weight}}{dalys\_disability\_weight}}\label{dalys_disability_weight}

\texttt{dalys\_disability\_weight} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dalys\_disability\_weight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dalys\_disability\_weight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{damerau\_levenshtein}}{damerau\_levenshtein}}\label{damerau_levenshtein}

\texttt{damerau\_levenshtein} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = damerau\_levenshtein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map damerau\_levenshtein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dantzig\_wolfe\_step}}{dantzig\_wolfe\_step}}\label{dantzig_wolfe_step}

\texttt{dantzig\_wolfe\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dantzig\_wolfe\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dantzig\_wolfe\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{darboux\_frame\_step}}{darboux\_frame\_step}}\label{darboux_frame_step}

\texttt{darboux\_frame\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = darboux\_frame\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map darboux\_frame\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dasum}}{dasum}}\label{dasum}

\texttt{dasum} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dasum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dasum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{data\_processing\_inequality}}{data\_processing\_inequality}}\label{data_processing_inequality}

\texttt{data\_processing\_inequality} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = data\_processing\_inequality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map data\_processing\_inequality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{date\_round\_iso}}{date\_round\_iso}}\label{date_round_iso}

\texttt{date\_round\_iso} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = date\_round\_iso $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map date\_round\_iso |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dawsn}}{dawsn}}\label{dawsn}

\texttt{dawsn} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dawsn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dawsn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dawson\_function}}{dawson\_function}}\label{dawson_function}

\texttt{dawson\_function} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dawson\_function $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dawson\_function |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{daxpy}}{daxpy}}\label{daxpy}

\texttt{daxpy} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = daxpy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map daxpy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{day\_of\_week\_iso}}{day\_of\_week\_iso}}\label{day_of_week_iso}

\texttt{day\_of\_week\_iso} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = day\_of\_week\_iso $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map day\_of\_week\_iso |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{day\_of\_week\_zeller}}{day\_of\_week\_zeller}}\label{day_of_week_zeller}

\texttt{day\_of\_week\_zeller} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = day\_of\_week\_zeller $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map day\_of\_week\_zeller |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{day\_of\_year}}{day\_of\_year}}\label{day_of_year}

\texttt{day\_of\_year} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = day\_of\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map day\_of\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{days\_between}}{days\_between}}\label{days_between}

\texttt{days\_between} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = days\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map days\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{days\_in\_month}}{days\_in\_month}}\label{days_in_month}

\texttt{days\_in\_month} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = days\_in\_month $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map days\_in\_month |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{days\_in\_month\_fn}}{days\_in\_month\_fn}}\label{days_in_month_fn}

\texttt{days\_in\_month\_fn} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = days\_in\_month\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map days\_in\_month\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{days\_in\_year}}{days\_in\_year}}\label{days_in_year}

\texttt{days\_in\_year} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = days\_in\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map days\_in\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{days\_to\_hours}}{days\_to\_hours}}\label{days_to_hours}

\texttt{days\_to\_hours} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = days\_to\_hours $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{days\_to\_seconds}}{days\_to\_seconds}}\label{days_to_seconds}

\texttt{days\_to\_seconds} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = days\_to\_seconds $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{daysinmo}}{daysinmo}}\label{daysinmo}

\texttt{daysinmo} --- extended stdlib batch 3 builtin. Alias for
\texttt{days\_in\_month\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = daysinmo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map daysinmo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db}}{db}}\label{db}

\texttt{db} --- physics formulas builtin. Alias for
\texttt{decibel\_ratio}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db4\_coeffs}}{db4\_coeffs}}\label{db4_coeffs}

\texttt{db4\_coeffs} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db4\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db4\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db4\_wavelet\_step}}{db4\_wavelet\_step}}\label{db4_wavelet_step}

\texttt{db4\_wavelet\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db4\_wavelet\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db4\_wavelet\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db6\_coeffs}}{db6\_coeffs}}\label{db6_coeffs}

\texttt{db6\_coeffs} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db6\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db6\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_anti\_entropy\_pull\_step}}{db\_anti\_entropy\_pull\_step}}\label{db_anti_entropy_pull_step}

\texttt{db\_anti\_entropy\_pull\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_anti\_entropy\_pull\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_anti\_entropy\_pull\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_anti\_entropy\_step}}{db\_anti\_entropy\_step}}\label{db_anti_entropy_step}

\texttt{db\_anti\_entropy\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_anti\_entropy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_anti\_entropy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_arc\_cache\_score}}{db\_arc\_cache\_score}}\label{db_arc_cache_score}

\texttt{db\_arc\_cache\_score} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_arc\_cache\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_arc\_cache\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_async\_commit\_check}}{db\_async\_commit\_check}}\label{db_async_commit_check}

\texttt{db\_async\_commit\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_async\_commit\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_async\_commit\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_avalanche\_query\_step}}{db\_avalanche\_query\_step}}\label{db_avalanche_query_step}

\texttt{db\_avalanche\_query\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_avalanche\_query\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_avalanche\_query\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_b\_tree\_merge}}{db\_b\_tree\_merge}}\label{db_b_tree_merge}

\texttt{db\_b\_tree\_merge} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_b\_tree\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_b\_tree\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_b\_tree\_split}}{db\_b\_tree\_split}}\label{db_b_tree_split}

\texttt{db\_b\_tree\_split} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_b\_tree\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_b\_tree\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_block\_cache\_hit\_rate}}{db\_block\_cache\_hit\_rate}}\label{db_block_cache_hit_rate}

\texttt{db\_block\_cache\_hit\_rate} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_block\_cache\_hit\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_block\_cache\_hit\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_bloom\_filter\_bit\_index}}{db\_bloom\_filter\_bit\_index}}\label{db_bloom_filter_bit_index}

\texttt{db\_bloom\_filter\_bit\_index} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_bloom\_filter\_bit\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_bloom\_filter\_bit\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_buffer\_pool\_score}}{db\_buffer\_pool\_score}}\label{db_buffer_pool_score}

\texttt{db\_buffer\_pool\_score} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_buffer\_pool\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_buffer\_pool\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_byzantine\_quorum\_size}}{db\_byzantine\_quorum\_size}}\label{db_byzantine_quorum_size}

\texttt{db\_byzantine\_quorum\_size} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_byzantine\_quorum\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_byzantine\_quorum\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_causal\_consistency\_check}}{db\_causal\_consistency\_check}}\label{db_causal_consistency_check}

\texttt{db\_causal\_consistency\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_causal\_consistency\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_causal\_consistency\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_chao\_estimator\_step}}{db\_chao\_estimator\_step}}\label{db_chao_estimator_step}

\texttt{db\_chao\_estimator\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_chao\_estimator\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_chao\_estimator\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_chord\_finger\_index}}{db\_chord\_finger\_index}}\label{db_chord_finger_index}

\texttt{db\_chord\_finger\_index} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_chord\_finger\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_chord\_finger\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_chubby\_lease\_step}}{db\_chubby\_lease\_step}}\label{db_chubby_lease_step}

\texttt{db\_chubby\_lease\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_chubby\_lease\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_chubby\_lease\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_circuit\_breaker\_step}}{db\_circuit\_breaker\_step}}\label{db_circuit_breaker_step}

\texttt{db\_circuit\_breaker\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_circuit\_breaker\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_circuit\_breaker\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_clock\_cache\_hand}}{db\_clock\_cache\_hand}}\label{db_clock_cache_hand}

\texttt{db\_clock\_cache\_hand} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_clock\_cache\_hand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_clock\_cache\_hand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_clock\_skew\_estimate}}{db\_clock\_skew\_estimate}}\label{db_clock_skew_estimate}

\texttt{db\_clock\_skew\_estimate} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_clock\_skew\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_clock\_skew\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_compaction\_score}}{db\_compaction\_score}}\label{db_compaction_score}

\texttt{db\_compaction\_score} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_compaction\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_compaction\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_consensus\_quorum\_size}}{db\_consensus\_quorum\_size}}\label{db_consensus_quorum_size}

\texttt{db\_consensus\_quorum\_size} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_consensus\_quorum\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_consensus\_quorum\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_consistent\_hash\_index}}{db\_consistent\_hash\_index}}\label{db_consistent_hash_index}

\texttt{db\_consistent\_hash\_index} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_consistent\_hash\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_consistent\_hash\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_consistent\_lookup\_id}}{db\_consistent\_lookup\_id}}\label{db_consistent_lookup_id}

\texttt{db\_consistent\_lookup\_id} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_consistent\_lookup\_id $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_consistent\_lookup\_id |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_count\_min\_sketch\_bin}}{db\_count\_min\_sketch\_bin}}\label{db_count_min_sketch_bin}

\texttt{db\_count\_min\_sketch\_bin} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_count\_min\_sketch\_bin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_count\_min\_sketch\_bin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_crdt\_g\_counter\_merge}}{db\_crdt\_g\_counter\_merge}}\label{db_crdt_g_counter_merge}

\texttt{db\_crdt\_g\_counter\_merge} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_crdt\_g\_counter\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_crdt\_g\_counter\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_crdt\_lww\_register\_merge}}{db\_crdt\_lww\_register\_merge}}\label{db_crdt_lww_register_merge}

\texttt{db\_crdt\_lww\_register\_merge} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_crdt\_lww\_register\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_crdt\_lww\_register\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_crdt\_pn\_counter\_merge}}{db\_crdt\_pn\_counter\_merge}}\label{db_crdt_pn_counter_merge}

\texttt{db\_crdt\_pn\_counter\_merge} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_crdt\_pn\_counter\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_crdt\_pn\_counter\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_crdt\_set\_or\_merge}}{db\_crdt\_set\_or\_merge}}\label{db_crdt_set_or_merge}

\texttt{db\_crdt\_set\_or\_merge} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_crdt\_set\_or\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_crdt\_set\_or\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_cuckoo\_filter\_fingerprint}}{db\_cuckoo\_filter\_fingerprint}}\label{db_cuckoo_filter_fingerprint}

\texttt{db\_cuckoo\_filter\_fingerprint} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_cuckoo\_filter\_fingerprint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_cuckoo\_filter\_fingerprint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_dd\_sketch\_bin}}{db\_dd\_sketch\_bin}}\label{db_dd_sketch_bin}

\texttt{db\_dd\_sketch\_bin} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_dd\_sketch\_bin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_dd\_sketch\_bin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_dht\_replicate\_factor}}{db\_dht\_replicate\_factor}}\label{db_dht_replicate_factor}

\texttt{db\_dht\_replicate\_factor} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_dht\_replicate\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_dht\_replicate\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_distinct\_estimate\_hll}}{db\_distinct\_estimate\_hll}}\label{db_distinct_estimate_hll}

\texttt{db\_distinct\_estimate\_hll} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_distinct\_estimate\_hll $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_distinct\_estimate\_hll |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_distinct\_estimate\_lpc}}{db\_distinct\_estimate\_lpc}}\label{db_distinct_estimate_lpc}

\texttt{db\_distinct\_estimate\_lpc} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_distinct\_estimate\_lpc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_distinct\_estimate\_lpc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_eventual\_consistency\_check}}{db\_eventual\_consistency\_check}}\label{db_eventual_consistency_check}

\texttt{db\_eventual\_consistency\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_eventual\_consistency\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_eventual\_consistency\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_freshness\_score}}{db\_freshness\_score}}\label{db_freshness_score}

\texttt{db\_freshness\_score} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_freshness\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_freshness\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_gossip\_fanout\_step}}{db\_gossip\_fanout\_step}}\label{db_gossip_fanout_step}

\texttt{db\_gossip\_fanout\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_gossip\_fanout\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_gossip\_fanout\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_group\_commit\_count}}{db\_group\_commit\_count}}\label{db_group_commit_count}

\texttt{db\_group\_commit\_count} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_group\_commit\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_group\_commit\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_hash\_join\_cost}}{db\_hash\_join\_cost}}\label{db_hash_join_cost}

\texttt{db\_hash\_join\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_hash\_join\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_hash\_join\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_hinted\_handoff\_step}}{db\_hinted\_handoff\_step}}\label{db_hinted_handoff_step}

\texttt{db\_hinted\_handoff\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_hinted\_handoff\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_hinted\_handoff\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_histogram\_bucket\_index}}{db\_histogram\_bucket\_index}}\label{db_histogram_bucket_index}

\texttt{db\_histogram\_bucket\_index} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_histogram\_bucket\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_histogram\_bucket\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_honey\_badger\_step}}{db\_honey\_badger\_step}}\label{db_honey_badger_step}

\texttt{db\_honey\_badger\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_honey\_badger\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_honey\_badger\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_hybrid\_logical\_clock}}{db\_hybrid\_logical\_clock}}\label{db_hybrid_logical_clock}

\texttt{db\_hybrid\_logical\_clock} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_hybrid\_logical\_clock $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_hybrid\_logical\_clock |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_hyperloglog\_register\_max}}{db\_hyperloglog\_register\_max}}\label{db_hyperloglog_register_max}

\texttt{db\_hyperloglog\_register\_max} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_hyperloglog\_register\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_hyperloglog\_register\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_index\_scan\_cost}}{db\_index\_scan\_cost}}\label{db_index_scan_cost}

\texttt{db\_index\_scan\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_index\_scan\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_index\_scan\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_index\_seek\_cost}}{db\_index\_seek\_cost}}\label{db_index_seek_cost}

\texttt{db\_index\_seek\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_index\_seek\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_index\_seek\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_jaccard\_minhash\_estimate}}{db\_jaccard\_minhash\_estimate}}\label{db_jaccard_minhash_estimate}

\texttt{db\_jaccard\_minhash\_estimate} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_jaccard\_minhash\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_jaccard\_minhash\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_join\_selectivity\_step}}{db\_join\_selectivity\_step}}\label{db_join_selectivity_step}

\texttt{db\_join\_selectivity\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_join\_selectivity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_join\_selectivity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_jump\_hash\_bucket}}{db\_jump\_hash\_bucket}}\label{db_jump_hash_bucket}

\texttt{db\_jump\_hash\_bucket} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_jump\_hash\_bucket $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_jump\_hash\_bucket |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_kademlia\_xor\_distance}}{db\_kademlia\_xor\_distance}}\label{db_kademlia_xor_distance}

\texttt{db\_kademlia\_xor\_distance} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_kademlia\_xor\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_kademlia\_xor\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_kll\_quantile\_step}}{db\_kll\_quantile\_step}}\label{db_kll_quantile_step}

\texttt{db\_kll\_quantile\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_kll\_quantile\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_kll\_quantile\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_lamport\_timestamp}}{db\_lamport\_timestamp}}\label{db_lamport_timestamp}

\texttt{db\_lamport\_timestamp} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_lamport\_timestamp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_lamport\_timestamp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_leaky\_bucket\_step}}{db\_leaky\_bucket\_step}}\label{db_leaky_bucket_step}

\texttt{db\_leaky\_bucket\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_leaky\_bucket\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_leaky\_bucket\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_levelled\_compaction\_step}}{db\_levelled\_compaction\_step}}\label{db_levelled_compaction_step}

\texttt{db\_levelled\_compaction\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_levelled\_compaction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_levelled\_compaction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_lfu\_cache\_decay}}{db\_lfu\_cache\_decay}}\label{db_lfu_cache_decay}

\texttt{db\_lfu\_cache\_decay} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_lfu\_cache\_decay $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_lfu\_cache\_decay |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_linearizability\_check}}{db\_linearizability\_check}}\label{db_linearizability_check}

\texttt{db\_linearizability\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_linearizability\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_linearizability\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_logical\_clock\_step}}{db\_logical\_clock\_step}}\label{db_logical_clock_step}

\texttt{db\_logical\_clock\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_logical\_clock\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_logical\_clock\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_lru\_cache\_eviction\_age}}{db\_lru\_cache\_eviction\_age}}\label{db_lru_cache_eviction_age}

\texttt{db\_lru\_cache\_eviction\_age} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_lru\_cache\_eviction\_age $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_lru\_cache\_eviction\_age |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_lsm\_compaction\_step}}{db\_lsm\_compaction\_step}}\label{db_lsm_compaction_step}

\texttt{db\_lsm\_compaction\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_lsm\_compaction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_lsm\_compaction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_maglev\_hash\_step}}{db\_maglev\_hash\_step}}\label{db_maglev_hash_step}

\texttt{db\_maglev\_hash\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_maglev\_hash\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_maglev\_hash\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_merge\_join\_cost}}{db\_merge\_join\_cost}}\label{db_merge_join_cost}

\texttt{db\_merge\_join\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_merge\_join\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_merge\_join\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_merkle\_node\_hash}}{db\_merkle\_node\_hash}}\label{db_merkle_node_hash}

\texttt{db\_merkle\_node\_hash} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_merkle\_node\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_merkle\_node\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_merkle\_path\_verify}}{db\_merkle\_path\_verify}}\label{db_merkle_path_verify}

\texttt{db\_merkle\_path\_verify} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_merkle\_path\_verify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_merkle\_path\_verify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_min\_hash\_value}}{db\_min\_hash\_value}}\label{db_min_hash_value}

\texttt{db\_min\_hash\_value} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_min\_hash\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_min\_hash\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_nested\_loop\_cost}}{db\_nested\_loop\_cost}}\label{db_nested_loop_cost}

\texttt{db\_nested\_loop\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_nested\_loop\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_nested\_loop\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_page\_cache\_eviction\_age}}{db\_page\_cache\_eviction\_age}}\label{db_page_cache_eviction_age}

\texttt{db\_page\_cache\_eviction\_age} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_page\_cache\_eviction\_age $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_page\_cache\_eviction\_age |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_partition\_failure\_check}}{db\_partition\_failure\_check}}\label{db_partition_failure_check}

\texttt{db\_partition\_failure\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_partition\_failure\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_partition\_failure\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_partitions\_for\_n}}{db\_partitions\_for\_n}}\label{db_partitions_for_n}

\texttt{db\_partitions\_for\_n} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_partitions\_for\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_partitions\_for\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_pastry\_routing\_step}}{db\_pastry\_routing\_step}}\label{db_pastry_routing_step}

\texttt{db\_pastry\_routing\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_pastry\_routing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_pastry\_routing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_paxos\_propose\_id}}{db\_paxos\_propose\_id}}\label{db_paxos_propose_id}

\texttt{db\_paxos\_propose\_id} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_paxos\_propose\_id $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_paxos\_propose\_id |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_pbft\_view\_change}}{db\_pbft\_view\_change}}\label{db_pbft_view_change}

\texttt{db\_pbft\_view\_change} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_pbft\_view\_change $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_pbft\_view\_change |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_power}}{db\_power}}\label{db_power-1}

\texttt{db\_power} --- batch 12 builtin. Alias for \texttt{dB\_power}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_quantile\_estimate\_p99}}{db\_quantile\_estimate\_p99}}\label{db_quantile_estimate_p99}

\texttt{db\_quantile\_estimate\_p99} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_quantile\_estimate\_p99 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_quantile\_estimate\_p99 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_query\_cardinality}}{db\_query\_cardinality}}\label{db_query_cardinality}

\texttt{db\_query\_cardinality} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_query\_cardinality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_query\_cardinality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_query\_plan\_cost\_step}}{db\_query\_plan\_cost\_step}}\label{db_query_plan_cost_step}

\texttt{db\_query\_plan\_cost\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_query\_plan\_cost\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_query\_plan\_cost\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_quorum\_intersection\_check}}{db\_quorum\_intersection\_check}}\label{db_quorum_intersection_check}

\texttt{db\_quorum\_intersection\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_quorum\_intersection\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_quorum\_intersection\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_quotient\_filter\_canonical}}{db\_quotient\_filter\_canonical}}\label{db_quotient_filter_canonical}

\texttt{db\_quotient\_filter\_canonical} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_quotient\_filter\_canonical $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_quotient\_filter\_canonical |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_raft\_log\_match\_check}}{db\_raft\_log\_match\_check}}\label{db_raft_log_match_check}

\texttt{db\_raft\_log\_match\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_raft\_log\_match\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_raft\_log\_match\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_raft\_term\_advance}}{db\_raft\_term\_advance}}\label{db_raft_term_advance}

\texttt{db\_raft\_term\_advance} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_raft\_term\_advance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_raft\_term\_advance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_read\_amplification}}{db\_read\_amplification}}\label{db_read_amplification}

\texttt{db\_read\_amplification} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_read\_amplification $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_read\_amplification |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_read\_repair\_step}}{db\_read\_repair\_step}}\label{db_read_repair_step}

\texttt{db\_read\_repair\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_read\_repair\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_read\_repair\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_rendezvous\_hash\_score}}{db\_rendezvous\_hash\_score}}\label{db_rendezvous_hash_score}

\texttt{db\_rendezvous\_hash\_score} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_rendezvous\_hash\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_rendezvous\_hash\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_replica\_lag\_threshold}}{db\_replica\_lag\_threshold}}\label{db_replica_lag_threshold}

\texttt{db\_replica\_lag\_threshold} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_replica\_lag\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_replica\_lag\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_replication\_lag\_step}}{db\_replication\_lag\_step}}\label{db_replication_lag_step}

\texttt{db\_replication\_lag\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_replication\_lag\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_replication\_lag\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_reservoir\_sample\_index}}{db\_reservoir\_sample\_index}}\label{db_reservoir_sample_index}

\texttt{db\_reservoir\_sample\_index} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_reservoir\_sample\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_reservoir\_sample\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_seq\_scan\_cost}}{db\_seq\_scan\_cost}}\label{db_seq_scan_cost}

\texttt{db\_seq\_scan\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_seq\_scan\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_seq\_scan\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_simhash\_bit}}{db\_simhash\_bit}}\label{db_simhash_bit}

\texttt{db\_simhash\_bit} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_simhash\_bit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_simhash\_bit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_size\_tiered\_compaction}}{db\_size\_tiered\_compaction}}\label{db_size_tiered_compaction}

\texttt{db\_size\_tiered\_compaction} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_size\_tiered\_compaction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_size\_tiered\_compaction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_skiplist\_height\_pick}}{db\_skiplist\_height\_pick}}\label{db_skiplist_height_pick}

\texttt{db\_skiplist\_height\_pick} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_skiplist\_height\_pick $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_skiplist\_height\_pick |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_sort\_cost\_estimate}}{db\_sort\_cost\_estimate}}\label{db_sort_cost_estimate}

\texttt{db\_sort\_cost\_estimate} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_sort\_cost\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_sort\_cost\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_space\_amplification}}{db\_space\_amplification}}\label{db_space_amplification}

\texttt{db\_space\_amplification} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_space\_amplification $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_space\_amplification |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_split\_brain\_check}}{db\_split\_brain\_check}}\label{db_split_brain_check}

\texttt{db\_split\_brain\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_split\_brain\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_split\_brain\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_strong\_consistency\_check}}{db\_strong\_consistency\_check}}\label{db_strong_consistency_check}

\texttt{db\_strong\_consistency\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_strong\_consistency\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_strong\_consistency\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_synchronous\_commit\_check}}{db\_synchronous\_commit\_check}}\label{db_synchronous_commit_check}

\texttt{db\_synchronous\_commit\_check} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_synchronous\_commit\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_synchronous\_commit\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_t\_digest\_centroid}}{db\_t\_digest\_centroid}}\label{db_t_digest_centroid}

\texttt{db\_t\_digest\_centroid} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_t\_digest\_centroid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_t\_digest\_centroid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_three\_phase\_commit\_step}}{db\_three\_phase\_commit\_step}}\label{db_three_phase_commit_step}

\texttt{db\_three\_phase\_commit\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_three\_phase\_commit\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_three\_phase\_commit\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_throttle\_token\_step}}{db\_throttle\_token\_step}}\label{db_throttle_token_step}

\texttt{db\_throttle\_token\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_throttle\_token\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_throttle\_token\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_tinylfu\_admit\_score}}{db\_tinylfu\_admit\_score}}\label{db_tinylfu_admit_score}

\texttt{db\_tinylfu\_admit\_score} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_tinylfu\_admit\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_tinylfu\_admit\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_to\_amp}}{db\_to\_amp}}\label{db_to_amp}

\texttt{db\_to\_amp} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_to\_amp $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_token\_bucket\_step}}{db\_token\_bucket\_step}}\label{db_token_bucket_step}

\texttt{db\_token\_bucket\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_token\_bucket\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_token\_bucket\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_two\_phase\_commit\_step}}{db\_two\_phase\_commit\_step}}\label{db_two_phase_commit_step}

\texttt{db\_two\_phase\_commit\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_two\_phase\_commit\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_two\_phase\_commit\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_universal\_compaction\_step}}{db\_universal\_compaction\_step}}\label{db_universal_compaction_step}

\texttt{db\_universal\_compaction\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_universal\_compaction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_universal\_compaction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_vector\_clock\_merge}}{db\_vector\_clock\_merge}}\label{db_vector_clock_merge}

\texttt{db\_vector\_clock\_merge} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_vector\_clock\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_vector\_clock\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_voltage}}{db\_voltage}}\label{db_voltage-1}

\texttt{db\_voltage} --- batch 12 builtin. Alias for
\texttt{dB\_voltage}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_voltage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_voltage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_w\_tinylfu\_freq}}{db\_w\_tinylfu\_freq}}\label{db_w_tinylfu_freq}

\texttt{db\_w\_tinylfu\_freq} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_w\_tinylfu\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_w\_tinylfu\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_wal\_fsync\_cost}}{db\_wal\_fsync\_cost}}\label{db_wal_fsync_cost}

\texttt{db\_wal\_fsync\_cost} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_wal\_fsync\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_wal\_fsync\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_write\_amplification}}{db\_write\_amplification}}\label{db_write_amplification}

\texttt{db\_write\_amplification} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_write\_amplification $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_write\_amplification |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{db\_zab\_epoch\_step}}{db\_zab\_epoch\_step}}\label{db_zab_epoch_step}

\texttt{db\_zab\_epoch\_step} --- batch 48 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = db\_zab\_epoch\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map db\_zab\_epoch\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dbinom}}{dbinom}}\label{dbinom}

\texttt{dbinom} --- binomial PMF. P(X = k) for Binom(n, p). Args: k, n,
p.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dbinom(5, 10, 0.5)   \# P(exactly 5 heads in 10 flips)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dbmclose}}{dbmclose}}\label{dbmclose}

\texttt{dbmclose} --- ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dbmclose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dbmclose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dbmopen}}{dbmopen}}\label{dbmopen}

\texttt{dbmopen} --- ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dbmopen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dbmopen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dbsize}}{dbsize}}\label{dbsize}

\texttt{dbsize} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dbsize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dbsize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dchisq}}{dchisq}}\label{dchisq}

\texttt{dchisq} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dchisq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dchisq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dct}}{dct}}\label{dct}

\texttt{dct} computes the Type-II Discrete Cosine Transform of a signal.
Used in JPEG, MP3, and speech processing.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @coeffs = @\{dct([1,2,3,4])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dde\_euler\_step}}{dde\_euler\_step}}\label{dde_euler_step}

\texttt{dde\_euler\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dde\_euler\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dde\_euler\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ddot}}{ddot}}\label{ddot}

\texttt{ddot} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ddot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ddot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ddpg\_critic\_loss\_step}}{ddpg\_critic\_loss\_step}}\label{ddpg_critic_loss_step}

\texttt{ddpg\_critic\_loss\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ddpg\_critic\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ddpg\_critic\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ddrot}}{ddrot}}\label{ddrot}

\texttt{ddrot} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ddrot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ddrot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ddt}}{ddt}}\label{ddt}

\texttt{ddt} --- extended stdlib builtin. Alias for \texttt{dedent}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ddt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ddt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{de\_broglie}}{de\_broglie}}\label{de_broglie}

\texttt{de\_broglie} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = de\_broglie $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map de\_broglie |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{de\_broglie\_wavelength}}{de\_broglie\_wavelength}}\label{de_broglie_wavelength}

\texttt{de\_broglie\_wavelength(\$mass,\ \$velocity)} (alias
\texttt{debroglie}) --- quantum wavelength λ = h/(mv). Defaults to
electron mass.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p debroglie(9.109e{-}31, 1e6)   \# \textasciitilde{}7.3e{-}10 m (electron at 1 km/s)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{de\_broglie\_wavelength\_kg}}{de\_broglie\_wavelength\_kg}}\label{de_broglie_wavelength_kg}

\texttt{de\_broglie\_wavelength\_kg} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = de\_broglie\_wavelength\_kg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map de\_broglie\_wavelength\_kg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{de\_rham\_zero}}{de\_rham\_zero}}\label{de_rham_zero}

\texttt{de\_rham\_zero} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = de\_rham\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map de\_rham\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{de\_sitter\_metric\_step}}{de\_sitter\_metric\_step}}\label{de_sitter_metric_step}

\texttt{de\_sitter\_metric\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = de\_sitter\_metric\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map de\_sitter\_metric\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{de\_sitter\_radius\_step}}{de\_sitter\_radius\_step}}\label{de_sitter_radius_step}

\texttt{de\_sitter\_radius\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = de\_sitter\_radius\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map de\_sitter\_radius\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deadweight\_loss}}{deadweight\_loss}}\label{deadweight_loss}

\texttt{deadweight\_loss} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deadweight\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deadweight\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deal\_n\_k}}{deal\_n\_k}}\label{deal_n_k}

\texttt{deal\_n\_k} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deal\_n\_k $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deal\_n\_k |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{debug\_object}}{debug\_object}}\label{debug_object}

\texttt{debug\_object} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = debug\_object $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map debug\_object |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{debug\_val}}{debug\_val}}\label{debug_val}

\texttt{debug\_val} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = debug\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map debug\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{debye\_huckel}}{debye\_huckel}}\label{debye_huckel}

\texttt{debye\_huckel} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = debye\_huckel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map debye\_huckel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{debye\_huckel\_activity}}{debye\_huckel\_activity}}\label{debye_huckel_activity}

\texttt{debye\_huckel\_activity} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = debye\_huckel\_activity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map debye\_huckel\_activity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{debye\_huckel\_screening\_factor}}{debye\_huckel\_screening\_factor}}\label{debye_huckel_screening_factor}

\texttt{debye\_huckel\_screening\_factor} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = debye\_huckel\_screening\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map debye\_huckel\_screening\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{debye\_length\_electrolyte}}{debye\_length\_electrolyte}}\label{debye_length_electrolyte}

\texttt{debye\_length\_electrolyte} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = debye\_length\_electrolyte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map debye\_length\_electrolyte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dec}}{dec}}\label{dec}

\texttt{dec} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dec\_each}}{dec\_each}}\label{dec_each}

\texttt{dec\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dec\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dec\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deceleration\_q}}{deceleration\_q}}\label{deceleration_q}

\texttt{deceleration\_q} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deceleration\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deceleration\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{decibel\_ratio}}{decibel\_ratio}}\label{decibel_ratio}

\texttt{decibel\_ratio} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = decibel\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map decibel\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{decimate\_step}}{decimate\_step}}\label{decimate_step}

\texttt{decimate\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = decimate\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map decimate\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{decode\_base}}{decode\_base}}\label{decode_base}

\texttt{decode\_base} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = decode\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map decode\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{decoherence\_time}}{decoherence\_time}}\label{decoherence_time}

\texttt{decoherence\_time} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = decoherence\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map decoherence\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deconvolve\_step}}{deconvolve\_step}}\label{deconvolve_step}

\texttt{deconvolve\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deconvolve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deconvolve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{decr}}{decr}}\label{decr}

\texttt{decr} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = decr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map decr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{decrby}}{decrby}}\label{decrby}

\texttt{decrby} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = decrby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map decrby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dedent}}{dedent}}\label{dedent}

\texttt{dedent} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dedent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dedent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dedent\_text}}{dedent\_text}}\label{dedent_text}

\texttt{dedent\_text} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dedent\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dedent\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deep\_q\_target}}{deep\_q\_target}}\label{deep_q_target}

\texttt{deep\_q\_target} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deep\_q\_target $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deep\_q\_target |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{default\_to}}{default\_to}}\label{default_to}

\texttt{default\_to} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = default\_to $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map default\_to |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{defaultdict}}{defaultdict}}\label{defaultdict}

\texttt{defaultdict} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = defaultdict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map defaultdict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deferred\_acceptance}}{deferred\_acceptance}}\label{deferred_acceptance}

\texttt{deferred\_acceptance} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deferred\_acceptance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deferred\_acceptance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deferred\_acceptance\_step}}{deferred\_acceptance\_step}}\label{deferred_acceptance_step}

\texttt{deferred\_acceptance\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deferred\_acceptance\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deferred\_acceptance\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deficient\_numbers}}{deficient\_numbers}}\label{deficient_numbers}

\texttt{deficient\_numbers} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deficient\_numbers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deficient\_numbers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{defined\_count}}{defined\_count}}\label{defined_count}

\texttt{defined\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = defined\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map defined\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{definums}}{definums}}\label{definums}

\texttt{definums} --- number theory / primes builtin. Alias for
\texttt{deficient\_numbers}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = definums $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map definums |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deflate\_dynamic\_huffman}}{deflate\_dynamic\_huffman}}\label{deflate_dynamic_huffman}

\texttt{deflate\_dynamic\_huffman} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deflate\_dynamic\_huffman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deflate\_dynamic\_huffman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deflate\_encode\_huffman}}{deflate\_encode\_huffman}}\label{deflate_encode_huffman}

\texttt{deflate\_encode\_huffman} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deflate\_encode\_huffman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deflate\_encode\_huffman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deflate\_huffman\_lit}}{deflate\_huffman\_lit}}\label{deflate_huffman_lit}

\texttt{deflate\_huffman\_lit} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deflate\_huffman\_lit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deflate\_huffman\_lit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deflate\_static\_block}}{deflate\_static\_block}}\label{deflate_static_block}

\texttt{deflate\_static\_block} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deflate\_static\_block $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deflate\_static\_block |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deg\_to\_rad}}{deg\_to\_rad}}\label{deg_to_rad}

\texttt{deg\_to\_rad} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deg\_to\_rad $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{degrees}}{degrees}}\label{degrees}

\texttt{degrees} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = degrees $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map degrees |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{degrees\_to\_compass}}{degrees\_to\_compass}}\label{degrees_to_compass}

\texttt{degrees\_to\_compass} --- misc / utility builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = degrees\_to\_compass $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dela}}{dela}}\label{dela}

\texttt{dela} --- go/general functional utilities builtin. Alias for
\texttt{delete\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dela $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dela |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delby}}{delby}}\label{delby}

\texttt{delby} --- additional missing stdlib functions builtin. Alias
for \texttt{delete\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delete\_at}}{delete\_at}}\label{delete_at}

\texttt{delete\_at} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delete\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delete\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delete\_by}}{delete\_by}}\label{delete_by}

\texttt{delete\_by} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delete\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delete\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delete\_first}}{delete\_first}}\label{delete_first}

\texttt{delete\_first} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delete\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delete\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delfst}}{delfst}}\label{delfst}

\texttt{delfst} --- additional missing stdlib functions builtin. Alias
for \texttt{delete\_first}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delfst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delfst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_complex\_count}}{delta\_complex\_count}}\label{delta_complex_count}

\texttt{delta\_complex\_count} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_complex\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_complex\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_e}}{delta\_e}}\label{delta_e}

\texttt{delta\_e} --- batch 9 builtin. Alias for \texttt{delta\_e\_76}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_e $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_e |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_e2000}}{delta\_e2000}}\label{delta_e2000}

\texttt{delta\_e2000} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_e2000 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_e2000 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_e76}}{delta\_e76}}\label{delta_e76}

\texttt{delta\_e76} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_e76 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_e76 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_e94}}{delta\_e94}}\label{delta_e94}

\texttt{delta\_e94} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_e94 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_e94 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_e\_76}}{delta\_e\_76}}\label{delta_e_76}

\texttt{delta\_e\_76} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_e\_76 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_e\_76 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{delta\_e\_94}}{delta\_e\_94}}\label{delta_e_94}

\texttt{delta\_e\_94} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = delta\_e\_94 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map delta\_e\_94 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{demorse}}{demorse}}\label{demorse}

\texttt{demorse} --- encoding / phonetics builtin. Alias for
\texttt{morse\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = demorse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map demorse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{denavit\_hartenberg\_h}}{denavit\_hartenberg\_h}}\label{denavit_hartenberg_h}

\texttt{denavit\_hartenberg\_h} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = denavit\_hartenberg\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map denavit\_hartenberg\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dense\_rank}}{dense\_rank}}\label{dense_rank}

\texttt{dense\_rank} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dense\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dense\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{density}}{density}}\label{density}

\texttt{density} --- kernel density estimation with Gaussian kernel and
Silverman bandwidth. Returns {[}{[}x\_grid{]}, {[}density\_values{]}{]}.
Like R\textquotesingle s density().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($x, $y) = @\{density([1,2,2,3,3,3,4,4,5])\}}
\NormalTok{\# $x is grid of 512 points, $y is estimated density}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{density\_altitude\_full}}{density\_altitude\_full}}\label{density_altitude_full}

\texttt{density\_altitude\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = density\_altitude\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map density\_altitude\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{density\_altitude\_m}}{density\_altitude\_m}}\label{density_altitude_m}

\texttt{density\_altitude\_m} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = density\_altitude\_m $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map density\_altitude\_m |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{density\_matrix\_purity\_q}}{density\_matrix\_purity\_q}}\label{density_matrix_purity_q}

\texttt{density\_matrix\_purity\_q} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = density\_matrix\_purity\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map density\_matrix\_purity\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{depdbl}}{depdbl}}\label{depdbl}

\texttt{depdbl} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{depreciation\_double}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = depdbl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map depdbl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dependency\_parse\_eisner}}{dependency\_parse\_eisner}}\label{dependency_parse_eisner}

\texttt{dependency\_parse\_eisner} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dependency\_parse\_eisner $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dependency\_parse\_eisner |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dephasing\_channel}}{dephasing\_channel}}\label{dephasing_channel}

\texttt{dephasing\_channel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dephasing\_channel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dephasing\_channel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deplin}}{deplin}}\label{deplin}

\texttt{deplin} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{depreciation\_linear}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deplin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deplin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{depolarizing\_channel}}{depolarizing\_channel}}\label{depolarizing_channel}

\texttt{depolarizing\_channel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = depolarizing\_channel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map depolarizing\_channel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{depolarizing\_density\_2x2}}{depolarizing\_density\_2x2}}\label{depolarizing_density_2x2}

\texttt{depolarizing\_density\_2x2} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = depolarizing\_density\_2x2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map depolarizing\_density\_2x2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{depreciation\_double}}{depreciation\_double}}\label{depreciation_double}

\texttt{depreciation\_double} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = depreciation\_double $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map depreciation\_double |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{depreciation\_linear}}{depreciation\_linear}}\label{depreciation_linear}

\texttt{depreciation\_linear} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = depreciation\_linear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map depreciation\_linear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{derangements}}{derangements}}\label{derangements}

\texttt{derangements} counts the number of derangements (subfactorial
!n) --- permutations with no fixed points.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p derangements(4)   \# 9}
\NormalTok{p derangements(5)   \# 44}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deroman}}{deroman}}\label{deroman}

\texttt{deroman} --- roman numerals builtin. Alias for
\texttt{roman\_to\_int}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deroman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deroman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{describe}}{describe}}\label{describe}

\texttt{describe(@data)} --- returns a hashref with comprehensive
descriptive statistics: count, mean, std, min, 25\%, 50\%, 75\%, max.
Similar to pandas DataFrame.describe().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $stats = describe(1:100)}
\NormalTok{p $stats{-}\textgreater{}\{mean\}    \# 50.5}
\NormalTok{p $stats{-}\textgreater{}\{std\}     \# \textasciitilde{}29.0}
\NormalTok{p $stats{-}\textgreater{}\{"50\%"\}   \# median}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{destination\_point}}{destination\_point}}\label{destination_point}

\texttt{destination\_point} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = destination\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map destination\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{det}}{det}}\label{det}

\texttt{matrix\_det\_general} (aliases \texttt{mdetg}, \texttt{det})
computes the determinant of any NxN matrix via LU decomposition.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p det([[1,2,3],[4,5,6],[7,8,0]])  \# 27}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{detect}}{detect}}\label{detect}

\texttt{detect} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = detect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map detect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{deterministic\_prime}}{deterministic\_prime}}\label{deterministic_prime}

\texttt{deterministic\_prime} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = deterministic\_prime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map deterministic\_prime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{detrend\_linear}}{detrend\_linear}}\label{detrend_linear}

\texttt{detrend\_linear} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = detrend\_linear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map detrend\_linear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{detrended\_fluct\_alpha}}{detrended\_fluct\_alpha}}\label{detrended_fluct_alpha}

\texttt{detrended\_fluct\_alpha} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = detrended\_fluct\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map detrended\_fluct\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dew\_point}}{dew\_point}}\label{dew_point}

\texttt{dew\_point} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dew\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dew\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dew\_point\_magnus}}{dew\_point\_magnus}}\label{dew_point_magnus}

\texttt{dew\_point\_magnus} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dew\_point\_magnus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dew\_point\_magnus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dewpoint\_temperature\_full}}{dewpoint\_temperature\_full}}\label{dewpoint_temperature_full}

\texttt{dewpoint\_temperature\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dewpoint\_temperature\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dewpoint\_temperature\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df}}{df}}\label{df}

\texttt{df} --- data / network builtin. Alias for \texttt{dataframe}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_aggregate}}{df\_aggregate}}\label{df_aggregate}

\texttt{df\_aggregate} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_aggregate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_aggregate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_apply}}{df\_apply}}\label{df_apply}

\texttt{df\_apply} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_clip}}{df\_clip}}\label{df_clip}

\texttt{df\_clip} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_clip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_clip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_concat}}{df\_concat}}\label{df_concat}

\texttt{df\_concat} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_concat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_concat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_corr}}{df\_corr}}\label{df_corr}

\texttt{df\_corr} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_corr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_corr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_corrwith}}{df\_corrwith}}\label{df_corrwith}

\texttt{df\_corrwith} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_corrwith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_corrwith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_cov}}{df\_cov}}\label{df_cov}

\texttt{df\_cov} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_cov $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_cov |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_crosstab}}{df\_crosstab}}\label{df_crosstab}

\texttt{df\_crosstab} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_crosstab $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_crosstab |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_describe}}{df\_describe}}\label{df_describe}

\texttt{df\_describe} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_describe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_describe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_diff}}{df\_diff}}\label{df_diff}

\texttt{df\_diff} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_dist}}{df\_dist}}\label{df_dist}

\texttt{df\_dist} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_drop\_duplicates}}{df\_drop\_duplicates}}\label{df_drop_duplicates}

\texttt{df\_drop\_duplicates} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_drop\_duplicates $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_drop\_duplicates |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_dropna}}{df\_dropna}}\label{df_dropna}

\texttt{df\_dropna} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_dropna $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_dropna |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_duplicated}}{df\_duplicated}}\label{df_duplicated}

\texttt{df\_duplicated} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_duplicated $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_duplicated |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_eval}}{df\_eval}}\label{df_eval}

\texttt{df\_eval} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_ewm}}{df\_ewm}}\label{df_ewm}

\texttt{df\_ewm} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_ewm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_ewm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_expanding}}{df\_expanding}}\label{df_expanding}

\texttt{df\_expanding} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_expanding $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_expanding |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_explode}}{df\_explode}}\label{df_explode}

\texttt{df\_explode} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_explode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_explode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_fillna}}{df\_fillna}}\label{df_fillna}

\texttt{df\_fillna} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_fillna $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_fillna |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_filter}}{df\_filter}}\label{df_filter}

\texttt{df\_filter} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_filter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_filter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_get\_dummies}}{df\_get\_dummies}}\label{df_get_dummies}

\texttt{df\_get\_dummies} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_get\_dummies $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_get\_dummies |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_groupby}}{df\_groupby}}\label{df_groupby}

\texttt{df\_groupby} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_groupby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_groupby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_idxmax}}{df\_idxmax}}\label{df_idxmax}

\texttt{df\_idxmax} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_idxmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_idxmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_idxmin}}{df\_idxmin}}\label{df_idxmin}

\texttt{df\_idxmin} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_idxmin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_idxmin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_interpolate}}{df\_interpolate}}\label{df_interpolate}

\texttt{df\_interpolate} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_interpolate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_interpolate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_isnull}}{df\_isnull}}\label{df_isnull}

\texttt{df\_isnull} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_isnull $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_isnull |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_join}}{df\_join}}\label{df_join}

\texttt{df\_join} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_join $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_join |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_kurtosis}}{df\_kurtosis}}\label{df_kurtosis}

\texttt{df\_kurtosis} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_kurtosis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_kurtosis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_mad}}{df\_mad}}\label{df_mad}

\texttt{df\_mad} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_mad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_mad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_melt}}{df\_melt}}\label{df_melt}

\texttt{df\_melt} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_melt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_melt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_merge}}{df\_merge}}\label{df_merge}

\texttt{df\_merge} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_merge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_merge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_nlargest}}{df\_nlargest}}\label{df_nlargest}

\texttt{df\_nlargest} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_nlargest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_nlargest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_notnull}}{df\_notnull}}\label{df_notnull}

\texttt{df\_notnull} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_notnull $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_notnull |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_nsmallest}}{df\_nsmallest}}\label{df_nsmallest}

\texttt{df\_nsmallest} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_nsmallest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_nsmallest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_pct\_change}}{df\_pct\_change}}\label{df_pct_change}

\texttt{df\_pct\_change} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_pct\_change $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_pct\_change |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_pivot}}{df\_pivot}}\label{df_pivot}

\texttt{df\_pivot} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_pivot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_pivot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_pivot\_table}}{df\_pivot\_table}}\label{df_pivot_table}

\texttt{df\_pivot\_table} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_pivot\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_pivot\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_quantile}}{df\_quantile}}\label{df_quantile}

\texttt{df\_quantile} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_quantile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_quantile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_query}}{df\_query}}\label{df_query}

\texttt{df\_query} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_query $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_query |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_rank}}{df\_rank}}\label{df_rank}

\texttt{df\_rank} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_replace}}{df\_replace}}\label{df_replace}

\texttt{df\_replace} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_replace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_replace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_resample}}{df\_resample}}\label{df_resample}

\texttt{df\_resample} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_resample $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_resample |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_reset\_index}}{df\_reset\_index}}\label{df_reset_index}

\texttt{df\_reset\_index} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_reset\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_reset\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_rolling}}{df\_rolling}}\label{df_rolling}

\texttt{df\_rolling} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_rolling $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_rolling |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_round}}{df\_round}}\label{df_round}

\texttt{df\_round} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_sample}}{df\_sample}}\label{df_sample}

\texttt{df\_sample} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_sample $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_sample |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_sem}}{df\_sem}}\label{df_sem}

\texttt{df\_sem} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_sem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_sem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_set\_index}}{df\_set\_index}}\label{df_set_index}

\texttt{df\_set\_index} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_set\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_set\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_shift}}{df\_shift}}\label{df_shift}

\texttt{df\_shift} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_shift $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_shift |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_skew}}{df\_skew}}\label{df_skew}

\texttt{df\_skew} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_skew $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_skew |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_sort\_values}}{df\_sort\_values}}\label{df_sort_values}

\texttt{df\_sort\_values} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_sort\_values $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_sort\_values |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_stack}}{df\_stack}}\label{df_stack}

\texttt{df\_stack} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_stack $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_stack |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_to\_datetime}}{df\_to\_datetime}}\label{df_to_datetime}

\texttt{df\_to\_datetime} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_to\_datetime $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_to\_numeric}}{df\_to\_numeric}}\label{df_to_numeric}

\texttt{df\_to\_numeric} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_to\_numeric $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_to\_timedelta}}{df\_to\_timedelta}}\label{df_to_timedelta}

\texttt{df\_to\_timedelta} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_to\_timedelta $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_transform}}{df\_transform}}\label{df_transform}

\texttt{df\_transform} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_transform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_transform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_unstack}}{df\_unstack}}\label{df_unstack}

\texttt{df\_unstack} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_unstack $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_unstack |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{df\_value\_counts}}{df\_value\_counts}}\label{df_value_counts}

\texttt{df\_value\_counts} --- batch 76 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = df\_value\_counts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map df\_value\_counts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfa\_minimize\_hopcroft}}{dfa\_minimize\_hopcroft}}\label{dfa_minimize_hopcroft}

\texttt{dfa\_minimize\_hopcroft} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfa\_minimize\_hopcroft $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfa\_minimize\_hopcroft |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfa\_simulate\_step}}{dfa\_simulate\_step}}\label{dfa_simulate_step}

\texttt{dfa\_simulate\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfa\_simulate\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfa\_simulate\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfact}}{dfact}}\label{dfact}

\texttt{dfact} --- math formulas builtin. Alias for
\texttt{double\_factorial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfs}}{dfs}}\label{dfs}

\texttt{dfs} --- extended stdlib builtin. Alias for
\texttt{dfs\_traverse}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfs\_postorder\_done}}{dfs\_postorder\_done}}\label{dfs_postorder_done}

\texttt{dfs\_postorder\_done} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfs\_postorder\_done $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfs\_postorder\_done |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfs\_preorder}}{dfs\_preorder}}\label{dfs_preorder}

\texttt{dfs\_preorder} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfs\_preorder $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfs\_preorder |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dfs\_traverse}}{dfs\_traverse}}\label{dfs_traverse}

\texttt{dfs\_traverse} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dfs\_traverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dfs\_traverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dft}}{dft}}\label{dft}

\texttt{dft(\textbackslash{}@signal)} --- computes the Discrete Fourier
Transform. Returns arrayref of complex numbers as {[}re, im{]} pairs.
O(n²) reference implementation; for large n, use FFT libraries.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @signal = map \{ sin(2 * 3.14159 * \_ / 64) \} 0:63}
\NormalTok{my $spectrum = dft(\textbackslash{}@signal)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dg\_from\_k}}{dg\_from\_k}}\label{dg_from_k}

\texttt{dg\_from\_k} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dg\_from\_k $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dg\_from\_k |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgbsv}}{dgbsv}}\label{dgbsv}

\texttt{dgbsv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgbsv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgbsv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgels}}{dgels}}\label{dgels}

\texttt{dgels} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgels $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgels |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgelsd}}{dgelsd}}\label{dgelsd}

\texttt{dgelsd} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgelsd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgelsd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgemm}}{dgemm}}\label{dgemm}

\texttt{dgemm} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgemm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgemm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgemm3m}}{dgemm3m}}\label{dgemm3m}

\texttt{dgemm3m} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgemm3m $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgemm3m |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgemv}}{dgemv}}\label{dgemv}

\texttt{dgemv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgemv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgemv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgeom}}{dgeom}}\label{dgeom}

\texttt{dgeom} --- geometric PMF P(X=k). Args: k, prob.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dgeom(3, 0.5)  \# P(first success on 4th trial)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgeqrf}}{dgeqrf}}\label{dgeqrf}

\texttt{dgeqrf} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgeqrf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgeqrf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgerqf}}{dgerqf}}\label{dgerqf}

\texttt{dgerqf} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgerqf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgerqf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgesv}}{dgesv}}\label{dgesv}

\texttt{dgesv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgesv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgesv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgesvd}}{dgesvd}}\label{dgesvd}

\texttt{dgesvd} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgesvd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgesvd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dgetrf}}{dgetrf}}\label{dgetrf}

\texttt{dgetrf} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dgetrf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dgetrf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dh\_secret}}{dh\_secret}}\label{dh_secret}

\texttt{dh\_secret} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dh\_secret $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dh\_secret |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dh\_shared}}{dh\_shared}}\label{dh_shared}

\texttt{dh\_shared} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dh\_shared $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dh\_shared |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dhyper}}{dhyper}}\label{dhyper}

\texttt{dhyper} --- hypergeometric PMF. Args: k, m (white), n (black),
nn (draws).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dhyper(2, 5, 5, 3)  \# P(2 white balls in 3 draws from 5W+5B)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diag}}{diag}}\label{diag}

\texttt{diag} --- extended stdlib builtin. Alias for \texttt{diagonal}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diagonal}}{diagonal}}\label{diagonal}

\texttt{diagonal} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diagonal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diagonal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diagonal\_dominance\_q}}{diagonal\_dominance\_q}}\label{diagonal_dominance_q}

\texttt{diagonal\_dominance\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diagonal\_dominance\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diagonal\_dominance\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diameter\_bfs}}{diameter\_bfs}}\label{diameter_bfs}

\texttt{diameter\_bfs} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diameter\_bfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diameter\_bfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diameter\_unweighted}}{diameter\_unweighted}}\label{diameter_unweighted}

\texttt{diameter\_unweighted} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diameter\_unweighted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diameter\_unweighted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dice\_coefficient}}{dice\_coefficient}}\label{dice_coefficient}

\texttt{dice\_coefficient} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dice\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dice\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dice\_roll}}{dice\_roll}}\label{dice_roll}

\texttt{dice\_roll} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dice\_roll $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dice\_roll |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dicecoef}}{dicecoef}}\label{dicecoef}

\texttt{dicecoef} --- extended stdlib batch 3 builtin. Alias for
\texttt{dice\_coefficient}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dicecoef $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dicecoef |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dickey\_fuller\_critical}}{dickey\_fuller\_critical}}\label{dickey_fuller_critical}

\texttt{dickey\_fuller\_critical} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dickey\_fuller\_critical $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dickey\_fuller\_critical |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dictator\_game\_share}}{dictator\_game\_share}}\label{dictator_game_share}

\texttt{dictator\_game\_share} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dictator\_game\_share $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dictator\_game\_share |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{did\_estimator}}{did\_estimator}}\label{did_estimator}

\texttt{did\_estimator} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = did\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map did\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{die\_if}}{die\_if}}\label{die_if}

\texttt{die\_if} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = die\_if $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map die\_if |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{die\_unless}}{die\_unless}}\label{die_unless}

\texttt{die\_unless} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = die\_unless $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map die\_unless |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diesel\_efficiency}}{diesel\_efficiency}}\label{diesel_efficiency}

\texttt{diesel\_efficiency} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diesel\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diesel\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff}}{diff}}\label{diff}

\texttt{diff} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff\_array}}{diff\_array}}\label{diff_array}

\texttt{numerical\_diff} (aliases \texttt{numdiff},
\texttt{diff\_array}) computes the numerical first derivative via
central differences. Returns an array.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @y = map \{ \_ ** 2 \} 0:10}
\NormalTok{my @dy = @\{numdiff(\textbackslash{}@y)\}  \# ≈ [0, 2, 4, 6, ...]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff\_coeff\_aqueous\_estimate}}{diff\_coeff\_aqueous\_estimate}}\label{diff_coeff_aqueous_estimate}

\texttt{diff\_coeff\_aqueous\_estimate} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diff\_coeff\_aqueous\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diff\_coeff\_aqueous\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff\_days}}{diff\_days}}\label{diff_days}

\texttt{diff\_days} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diff\_days $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diff\_days |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff\_hours}}{diff\_hours}}\label{diff_hours}

\texttt{diff\_hours} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diff\_hours $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diff\_hours |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff\_in\_diff}}{diff\_in\_diff}}\label{diff_in_diff}

\texttt{diff\_in\_diff} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diff\_in\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diff\_in\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diff\_lag}}{diff\_lag}}\label{diff_lag}

\texttt{diff\_lag} (alias \texttt{diff\_ts}) --- lagged differences.
Args: vec {[}, lag, differences{]}. Like R\textquotesingle s diff().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p diff\_lag([1,3,6,10])       \# [2,3,4] (lag=1)}
\NormalTok{p diff\_lag([1,3,6,10], 2)    \# [5,7] (lag=2)}
\NormalTok{p diff\_lag([1,3,6,10], 1, 2) \# [1,1] (second differences)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diffd}}{diffd}}\label{diffd}

\texttt{diffd} --- extended stdlib builtin. Alias for
\texttt{diff\_days}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diffd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diffd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diffh}}{diffh}}\label{diffh}

\texttt{diffh} --- extended stdlib builtin. Alias for
\texttt{diff\_hours}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diffh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diffh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diffraction\_grating\_angle}}{diffraction\_grating\_angle}}\label{diffraction_grating_angle}

\texttt{diffraction\_grating\_angle} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diffraction\_grating\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diffraction\_grating\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diffuse\_layer\_thickness}}{diffuse\_layer\_thickness}}\label{diffuse_layer_thickness}

\texttt{diffuse\_layer\_thickness} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diffuse\_layer\_thickness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diffuse\_layer\_thickness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diffusion\_layer\_thickness}}{diffusion\_layer\_thickness}}\label{diffusion_layer_thickness}

\texttt{diffusion\_layer\_thickness} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diffusion\_layer\_thickness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diffusion\_layer\_thickness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diffusion\_stability}}{diffusion\_stability}}\label{diffusion_stability}

\texttt{diffusion\_stability} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diffusion\_stability $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diffusion\_stability |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dig}}{dig}}\label{dig}

\texttt{dig} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dig $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dig |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digest\_auth\_quote}}{digest\_auth\_quote}}\label{digest_auth_quote}

\texttt{digest\_auth\_quote} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = digest\_auth\_quote $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map digest\_auth\_quote |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digital\_call}}{digital\_call}}\label{digital_call}

\texttt{digital\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = digital\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map digital\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digital\_root}}{digital\_root}}\label{digital_root}

\texttt{digital\_root} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = digital\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map digital\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digitize}}{digitize}}\label{digitize}

\texttt{digitize} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = digitize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map digitize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digits\_of}}{digits\_of}}\label{digits_of}

\texttt{digits\_of} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = digits\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map digits\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{digroot}}{digroot}}\label{digroot}

\texttt{digroot} --- extended stdlib batch 3 builtin. Alias for
\texttt{digital\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = digroot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map digroot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dijkstra}}{dijkstra}}\label{dijkstra}

\texttt{dijkstra} (alias \texttt{shortest\_path}) computes shortest
paths from a source node. Graph is a hash of \{node =\textgreater{}
{[}{[}neighbor, weight{]}, ...{]}\}. Returns \{node =\textgreater{}
distance\}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $g = \{A =\textgreater{} [["B",1],["C",4]], B =\textgreater{} [["C",2]], C =\textgreater{} []\}}
\NormalTok{my $d = dijkstra($g, "A")  \# \{A=\textgreater{}0, B=\textgreater{}1, C=\textgreater{}3\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dijkstra\_relax}}{dijkstra\_relax}}\label{dijkstra_relax}

\texttt{dijkstra\_relax} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dijkstra\_relax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dijkstra\_relax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dilution\_v2}}{dilution\_v2}}\label{dilution_v2}

\texttt{dilution\_v2} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dilution\_v2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dilution\_v2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dim}}{dim}}\label{dim}

\texttt{dim} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dinic\_blocking\_flow}}{dinic\_blocking\_flow}}\label{dinic_blocking_flow}

\texttt{dinic\_blocking\_flow} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dinic\_blocking\_flow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dinic\_blocking\_flow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dinic\_step}}{dinic\_step}}\label{dinic_step}

\texttt{dinic\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dinic\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dinic\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{diopter}}{diopter}}\label{diopter}

\texttt{diopter} --- physics formulas builtin. Alias for
\texttt{lens\_power}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = diopter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map diopter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{direct\_age\_adjusted}}{direct\_age\_adjusted}}\label{direct_age_adjusted}

\texttt{direct\_age\_adjusted} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = direct\_age\_adjusted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map direct\_age\_adjusted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dirs}}{dirs}}\label{dirs}

\texttt{dirs} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dirs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dirs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dirty\_price}}{dirty\_price}}\label{dirty_price}

\texttt{dirty\_price} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dirty\_price $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dirty\_price |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{disc\_excel}}{disc\_excel}}\label{disc_excel}

\texttt{disc\_excel} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = disc\_excel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map disc\_excel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{discount}}{discount}}\label{discount}

\texttt{discount} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = discount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map discount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{discount\_amount}}{discount\_amount}}\label{discount_amount}

\texttt{discount\_amount} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = discount\_amount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map discount\_amount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{discount\_continuous}}{discount\_continuous}}\label{discount_continuous}

\texttt{discount\_continuous} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = discount\_continuous $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map discount\_continuous |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{discount\_factor\_step}}{discount\_factor\_step}}\label{discount_factor_step}

\texttt{discount\_factor\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = discount\_factor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map discount\_factor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{discounted\_payback}}{discounted\_payback}}\label{discounted_payback}

\texttt{discounted\_payback(\$initial,\ \$rate,\ @cashflows)} ---
computes payback period using discounted cash flows. Accounts for time
value of money.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p discounted\_payback(1000, 0.1, 400, 400, 400, 400)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{discrete\_haar\_step}}{discrete\_haar\_step}}\label{discrete_haar_step}

\texttt{discrete\_haar\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = discrete\_haar\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map discrete\_haar\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{disk\_avail}}{disk\_avail}}\label{disk_avail}

\texttt{disk\_avail\ PATH} --- available disk space in bytes for
non-root users. Uses \texttt{f\_bavail} from \texttt{statvfs}, which
excludes blocks reserved for the superuser.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(disk\_avail)               \# 76.3 GiB}
\NormalTok{gauge(1 {-} disk\_avail / disk\_total) |\textgreater{} p  \# usage gauge}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{disk\_free}}{disk\_free}}\label{disk_free}

\texttt{disk\_free\ PATH} --- free disk space in bytes (superuser view).
Uses \texttt{f\_bfree} from \texttt{statvfs}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(disk\_free)                \# 76.3 GiB}
\NormalTok{p format\_bytes(disk\_free("/tmp"))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{disk\_total}}{disk\_total}}\label{disk_total}

\texttt{disk\_total\ PATH} --- total disk space in bytes for the
filesystem containing PATH (default \texttt{/}). Uses \texttt{statvfs}
on unix. Returns \texttt{undef} on unsupported platforms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(disk\_total)               \# 1.8 TiB}
\NormalTok{p format\_bytes(disk\_total("/home"))       \# specific mount}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{disk\_used}}{disk\_used}}\label{disk_used}

\texttt{disk\_used\ PATH} --- used disk space in bytes (total - free).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(disk\_used)                \# 1.7 TiB}
\NormalTok{my $pct = int(disk\_used / disk\_total * 100)}
\NormalTok{p "$pct\% disk used"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dissoc}}{dissoc}}\label{dissoc}

\texttt{dissoc} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dissoc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dissoc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dist}}{dist}}\label{dist}

\texttt{dist} --- extended stdlib builtin. Alias for \texttt{distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dist\_mat}}{dist\_mat}}\label{dist_mat}

\texttt{dist\_matrix} (alias \texttt{dist\_mat}) --- pairwise distance
matrix. Supports \textquotesingle euclidean\textquotesingle{} (default),
\textquotesingle manhattan\textquotesingle,
\textquotesingle maximum\textquotesingle. Like R\textquotesingle s
dist().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $D = dist\_mat([[0,0],[1,0],[0,1]])  \# 3x3 distance matrix}
\NormalTok{my $D2 = dist\_mat([[0,0],[1,1]], "manhattan")  \# Manhattan}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dist\_point\_line\_2d}}{dist\_point\_line\_2d}}\label{dist_point_line_2d}

\texttt{dist\_point\_line\_2d} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dist\_point\_line\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dist\_point\_line\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dist\_point\_plane\_3d}}{dist\_point\_plane\_3d}}\label{dist_point_plane_3d}

\texttt{dist\_point\_plane\_3d} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dist\_point\_plane\_3d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dist\_point\_plane\_3d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{distance}}{distance}}\label{distance}

\texttt{distance} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{distb}}{distb}}\label{distb}

\texttt{distb} --- additional missing stdlib functions builtin. Alias
for \texttt{distinct\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = distb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map distb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{distinct\_by}}{distinct\_by}}\label{distinct_by}

\texttt{distinct\_by} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = distinct\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map distinct\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{distinct\_count}}{distinct\_count}}\label{distinct_count}

\texttt{distinct\_count} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = distinct\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map distinct\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{divergence\_omega\_step}}{divergence\_omega\_step}}\label{divergence_omega_step}

\texttt{divergence\_omega\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = divergence\_omega\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map divergence\_omega\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{divisible\_goods\_proportional}}{divisible\_goods\_proportional}}\label{divisible_goods_proportional}

\texttt{divisible\_goods\_proportional} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = divisible\_goods\_proportional $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map divisible\_goods\_proportional |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{divisors}}{divisors}}\label{divisors}

\texttt{divisors} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = divisors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map divisors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{divmod}}{divmod}}\label{divmod}

\texttt{divmod} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = divmod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map divmod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{divs}}{divs}}\label{divs}

\texttt{divs} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{divisors}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = divs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map divs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{djb2}}{djb2}}\label{djb2}

\texttt{djb2} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = djb2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map djb2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{djb2\_hash}}{djb2\_hash}}\label{djb2_hash}

\texttt{djb2\_hash} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = djb2\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map djb2\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dm}}{dm}}\label{dm}

\texttt{dm} --- python/ruby stdlib builtin. Alias for \texttt{divmod}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dmetph}}{dmetph}}\label{dmetph}

\texttt{dmetph} --- encoding / phonetics builtin. Alias for
\texttt{double\_metaphone}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dmetph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dmetph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dnbinom}}{dnbinom}}\label{dnbinom}

\texttt{dnbinom} --- negative binomial PMF. Args: k, size, prob.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dnbinom(3, 5, 0.5)  \# P(3 failures before 5 successes)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dnds\_ratio}}{dnds\_ratio}}\label{dnds_ratio}

\texttt{dnds\_ratio} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dnds\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dnds\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dnorm}}{dnorm}}\label{dnorm}

\texttt{dnorm} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dnorm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dnorm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dnrm2}}{dnrm2}}\label{dnrm2}

\texttt{dnrm2} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dnrm2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dnrm2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{do\_call}}{do\_call}}\label{do_call}

\texttt{do\_call} --- call a function with args from a list. Like
R\textquotesingle s do.call().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = docall(fn \{ $\_[0] + $\_[1] \}, [3, 4])  \# 7}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{doctor}}{doctor}}\label{doctor}

\texttt{doctor} (alias \texttt{health}) --- runtime diagnostic report.
Prints version + binary path, runtime flags (\texttt{-\/-compat},
\texttt{-\/-no-interop}, \texttt{bigint}, \texttt{strict\_vars},
\texttt{strict\_refs}), environment overrides (\texttt{STRYKE\_NO\_TTY},
\texttt{STRYKE\_NO\_JIT}, \texttt{RUST\_LOG}, \ldots), reflection counts
(\texttt{\%b} primaries, \texttt{\%all} spellings, categories,
list-builtin extras), concurrency (logical CPUs + rayon pool size),
home/cache/config dirs, toolchain availability
(\texttt{rustc}/\texttt{cargo}/\texttt{perl}/\texttt{git}/\texttt{rg}),
and a battery of sanity checks. Returns the warning count as an integer
(0 = healthy).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{doctor              \# full report}
\NormalTok{my $w = doctor}
\NormalTok{exit($w == 0 ? 0 : 1)   \# CI{-}friendly health gate}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dodecahedral\_number}}{dodecahedral\_number}}\label{dodecahedral_number}

\texttt{dodecahedral\_number} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dodecahedral\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dodecahedral\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dodgson\_swap\_count}}{dodgson\_swap\_count}}\label{dodgson_swap_count}

\texttt{dodgson\_swap\_count} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dodgson\_swap\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dodgson\_swap\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dogleg\_step}}{dogleg\_step}}\label{dogleg_step}

\texttt{dogleg\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dogleg\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dogleg\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dollarde}}{dollarde}}\label{dollarde}

\texttt{dollarde} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dollarde $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dollarde |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dollarfr}}{dollarfr}}\label{dollarfr}

\texttt{dollarfr} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dollarfr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dollarfr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dom\_tree\_idom}}{dom\_tree\_idom}}\label{dom_tree_idom}

\texttt{dom\_tree\_idom} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dom\_tree\_idom $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dom\_tree\_idom |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dominance\_frontier}}{dominance\_frontier}}\label{dominance_frontier}

\texttt{dominance\_frontier} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dominance\_frontier $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dominance\_frontier |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dominating\_set\_greedy}}{dominating\_set\_greedy}}\label{dominating_set_greedy}

\texttt{dominating\_set\_greedy} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dominating\_set\_greedy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dominating\_set\_greedy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dominating\_set\_greedy\_step}}{dominating\_set\_greedy\_step}}\label{dominating_set_greedy_step}

\texttt{dominating\_set\_greedy\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dominating\_set\_greedy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dominating\_set\_greedy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dominating\_set\_lp\_bound}}{dominating\_set\_lp\_bound}}\label{dominating_set_lp_bound}

\texttt{dominating\_set\_lp\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dominating\_set\_lp\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dominating\_set\_lp\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{donaldson\_invariant}}{donaldson\_invariant}}\label{donaldson_invariant}

\texttt{donaldson\_invariant} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = donaldson\_invariant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map donaldson\_invariant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{doppler}}{doppler}}\label{doppler}

\texttt{doppler\_frequency(\$source\_freq,\ \$source\_vel,\ \$observer\_vel)}
(alias \texttt{doppler}) --- observed frequency with Doppler effect.
Uses speed of sound (343 m/s).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p doppler(440, {-}30, 0)   \# \textasciitilde{}482 Hz (ambulance approaching at 30 m/s)}
\NormalTok{p doppler(440, 30, 0)    \# \textasciitilde{}405 Hz (ambulance receding)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{doppler\_classical}}{doppler\_classical}}\label{doppler_classical}

\texttt{doppler\_classical} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = doppler\_classical $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map doppler\_classical |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{doppler\_relativistic}}{doppler\_relativistic}}\label{doppler_relativistic}

\texttt{doppler\_relativistic} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = doppler\_relativistic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map doppler\_relativistic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dopri5\_combine}}{dopri5\_combine}}\label{dopri5_combine}

\texttt{dopri5\_combine} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dopri5\_combine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dopri5\_combine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dorglq}}{dorglq}}\label{dorglq}

\texttt{dorglq} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dorglq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dorglq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dorgqr}}{dorgqr}}\label{dorgqr}

\texttt{dorgqr} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dorgqr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dorgqr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dot\_case}}{dot\_case}}\label{dot_case}

\texttt{dot\_case} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dot\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dot\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dot\_product}}{dot\_product}}\label{dot_product}

\texttt{dot\_product} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dot\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dot\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dotp}}{dotp}}\label{dotp}

\texttt{dotp} --- extended stdlib builtin. Alias for
\texttt{dot\_product}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dotp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dotp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double}}{double}}\label{double}

\texttt{double} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double\_auction\_step}}{double\_auction\_step}}\label{double_auction_step}

\texttt{double\_auction\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double\_auction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double\_auction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double\_each}}{double\_each}}\label{double_each}

\texttt{double\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double\_factorial}}{double\_factorial}}\label{double_factorial}

\texttt{double\_factorial} --- math formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double\_factorial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double\_factorial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double\_layer\_capacitance}}{double\_layer\_capacitance}}\label{double_layer_capacitance}

\texttt{double\_layer\_capacitance} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double\_layer\_capacitance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double\_layer\_capacitance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double\_metaphone}}{double\_metaphone}}\label{double_metaphone}

\texttt{double\_metaphone} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double\_metaphone $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double\_metaphone |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{double\_q\_learning\_step}}{double\_q\_learning\_step}}\label{double_q_learning_step}

\texttt{double\_q\_learning\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = double\_q\_learning\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map double\_q\_learning\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{doubling\_time\_growth}}{doubling\_time\_growth}}\label{doubling_time_growth}

\texttt{doubling\_time\_growth} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = doubling\_time\_growth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map doubling\_time\_growth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{downcase\_each}}{downcase\_each}}\label{downcase_each}

\texttt{downcase\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = downcase\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map downcase\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{downsample}}{downsample}}\label{downsample}

\texttt{downsample(\textbackslash{}@signal,\ \$factor)} (alias
\texttt{decimate}) --- reduces sample rate by keeping every nth sample.
Apply anti-aliasing filter first to avoid aliasing.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $decimated = decimate(\textbackslash{}@signal, 4)  \# keep every 4th sample}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{downto}}{downto}}\label{downto}

\texttt{downto} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = downto $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map downto |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{doy}}{doy}}\label{doy}

\texttt{doy} --- extended stdlib batch 3 builtin. Alias for
\texttt{day\_of\_year}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = doy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map doy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dpayback}}{dpayback}}\label{dpayback}

\texttt{dpayback} --- finance (extended) builtin. Alias for
\texttt{discounted\_payback}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dpayback $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dpayback |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dpbsv}}{dpbsv}}\label{dpbsv}

\texttt{dpbsv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dpbsv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dpbsv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dpll\_clause\_learning}}{dpll\_clause\_learning}}\label{dpll_clause_learning}

\texttt{dpll\_clause\_learning} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dpll\_clause\_learning $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dpll\_clause\_learning |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dpotrf}}{dpotrf}}\label{dpotrf}

\texttt{dpotrf} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dpotrf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dpotrf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dpss\_window}}{dpss\_window}}\label{dpss_window}

\texttt{dpss\_window} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dpss\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dpss\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dr}}{dr}}\label{dr}

\texttt{dr} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drag\_force}}{drag\_force}}\label{drag_force}

\texttt{drag\_force} (alias \texttt{fdrag}) computes aerodynamic drag: F
= 0.5·Cd·ρ·A·v². Args: drag\_coeff, air\_density, area, velocity.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p fdrag(0.47, 1.225, 0.01, 30)  \# drag on a ball at 30 m/s}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drag\_force\_quadratic}}{drag\_force\_quadratic}}\label{drag_force_quadratic}

\texttt{drag\_force\_quadratic} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drag\_force\_quadratic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drag\_force\_quadratic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drnk}}{drnk}}\label{drnk}

\texttt{drnk} --- extended stdlib builtin. Alias for
\texttt{dense\_rank}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drnk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drnk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drop\_at}}{drop\_at}}\label{drop_at}

\texttt{drop\_at} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drop\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drop\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drop\_every}}{drop\_every}}\label{drop_every}

\texttt{drop\_every} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drop\_every $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drop\_every |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drop\_last}}{drop\_last}}\label{drop_last}

\texttt{drop\_last} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drop\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drop\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drop\_n}}{drop\_n}}\label{drop_n}

\texttt{drop\_n} --- collection helpers (trivial) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drop\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drop\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drot}}{drot}}\label{drot}

\texttt{drot} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{drotg}}{drotg}}\label{drotg}

\texttt{drotg} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = drotg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map drotg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dsamp}}{dsamp}}\label{dsamp}

\texttt{dsamp} --- dsp / signal (extended) builtin. Alias for
\texttt{downsample}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dsamp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dsamp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dscal}}{dscal}}\label{dscal}

\texttt{dscal} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dscal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dscal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dsyevd}}{dsyevd}}\label{dsyevd}

\texttt{dsyevd} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dsyevd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dsyevd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dsyrk}}{dsyrk}}\label{dsyrk}

\texttt{dsyrk} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dsyrk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dsyrk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dt}}{dt}}\label{dt}

\texttt{dt} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dtbsv}}{dtbsv}}\label{dtbsv}

\texttt{dtbsv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dtbsv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dtbsv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dte}}{dte}}\label{dte}

\texttt{dte} --- date / time builtin. Alias for
\texttt{datetime\_from\_epoch}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dtf}}{dtf}}\label{dtf}

\texttt{dtf} --- date / time builtin. Alias for
\texttt{datetime\_strftime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dtf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dtf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dtrsm}}{dtrsm}}\label{dtrsm}

\texttt{dtrsm} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dtrsm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dtrsm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dtrsv}}{dtrsv}}\label{dtrsv}

\texttt{dtrsv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dtrsv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dtrsv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dump}}{dump}}\label{dump}

\texttt{dump} --- process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dump $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dump |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dunif}}{dunif}}\label{dunif}

\texttt{dunif} --- uniform PDF. Args: x, a, b.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p dunif(0.5, 0, 1)  \# 1.0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{duped}}{duped}}\label{duped}

\texttt{duplicated} --- boolean array: 1 if element appeared earlier in
the vector, 0 otherwise. Like R\textquotesingle s duplicated().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p duplicated([1,2,3,2,1])  \# [0,0,0,1,1]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{duplicate\_count}}{duplicate\_count}}\label{duplicate_count}

\texttt{duplicate\_count} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = duplicate\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map duplicate\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{durand\_kerner}}{durand\_kerner}}\label{durand_kerner}

\texttt{durand\_kerner} --- batch 10 builtin. Alias for
\texttt{polynomial\_roots\_dk}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = durand\_kerner $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map durand\_kerner |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{duration\_macaulay}}{duration\_macaulay}}\label{duration_macaulay}

\texttt{duration\_macaulay} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = duration\_macaulay $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map duration\_macaulay |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{durbin\_watson\_d}}{durbin\_watson\_d}}\label{durbin_watson_d}

\texttt{durbin\_watson\_d} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = durbin\_watson\_d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map durbin\_watson\_d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dutch\_auction}}{dutch\_auction}}\label{dutch_auction}

\texttt{dutch\_auction} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dutch\_auction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dutch\_auction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dutch\_auction\_step}}{dutch\_auction\_step}}\label{dutch_auction_step}

\texttt{dutch\_auction\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dutch\_auction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dutch\_auction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{dynamics\_db\_level}}{dynamics\_db\_level}}\label{dynamics_db_level}

\texttt{dynamics\_db\_level} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = dynamics\_db\_level $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map dynamics\_db\_level |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{each\_cons}}{each\_cons}}\label{each_cons}

\texttt{each\_cons} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = each\_cons $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map each\_cons |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{each\_slice}}{each\_slice}}\label{each_slice}

\texttt{each\_slice} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = each\_slice $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map each\_slice |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{each\_with\_index}}{each\_with\_index}}\label{each_with_index}

\texttt{each\_with\_index} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = each\_with\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map each\_with\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{each\_with\_object}}{each\_with\_object}}\label{each_with_object}

\texttt{each\_with\_object} --- additional missing stdlib functions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = each\_with\_object $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map each\_with\_object |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eadie\_hofstee\_y}}{eadie\_hofstee\_y}}\label{eadie_hofstee_y}

\texttt{eadie\_hofstee\_y} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eadie\_hofstee\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eadie\_hofstee\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ean13\_check}}{ean13\_check}}\label{ean13_check}

\texttt{ean13\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ean13\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ean13\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{earley\_complete}}{earley\_complete}}\label{earley_complete}

\texttt{earley\_complete} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = earley\_complete $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map earley\_complete |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{earley\_predict}}{earley\_predict}}\label{earley_predict}

\texttt{earley\_predict} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = earley\_predict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map earley\_predict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{earley\_scan}}{earley\_scan}}\label{earley_scan}

\texttt{earley\_scan} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = earley\_scan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map earley\_scan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{earth\_mass}}{earth\_mass}}\label{earth_mass}

\texttt{earth\_mass} (alias \texttt{mearth}) --- M⊕ ≈ 5.972×10²⁴ kg.
Mass of Earth.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mearth   \# 5.972167867e24 kg}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{earth\_radius}}{earth\_radius}}\label{earth_radius}

\texttt{earth\_radius} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = earth\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map earth\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{easter\_gregorian\_year}}{easter\_gregorian\_year}}\label{easter_gregorian_year}

\texttt{easter\_gregorian\_year} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = easter\_gregorian\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map easter\_gregorian\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{easter\_julian\_year}}{easter\_julian\_year}}\label{easter_julian_year}

\texttt{easter\_julian\_year} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = easter\_julian\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map easter\_julian\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{easter\_orthodox\_year}}{easter\_orthodox\_year}}\label{easter_orthodox_year}

\texttt{easter\_orthodox\_year} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = easter\_orthodox\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map easter\_orthodox\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{easter\_orthodox\_year\_2}}{easter\_orthodox\_year\_2}}\label{easter_orthodox_year_2}

\texttt{easter\_orthodox\_year\_2} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = easter\_orthodox\_year\_2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map easter\_orthodox\_year\_2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{easter\_sunday}}{easter\_sunday}}\label{easter_sunday}

\texttt{easter\_sunday} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = easter\_sunday $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map easter\_sunday |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{easter\_western}}{easter\_western}}\label{easter_western}

\texttt{easter\_western} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = easter\_western $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map easter\_western |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecc\_point\_double}}{ecc\_point\_double}}\label{ecc_point_double}

\texttt{ecc\_point\_double} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ecc\_point\_double $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ecc\_point\_double |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecdf}}{ecdf}}\label{ecdf}

\texttt{ecdf} --- empirical CDF: proportion of data ≤ x. Like
R\textquotesingle s ecdf().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ecdf([1,2,3,4,5], 3)  \# 0.6 (3 of 5 values ≤ 3)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{echarge}}{echarge}}\label{echarge}

\texttt{echarge} --- constants builtin. Alias for
\texttt{elementary\_charge}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = echarge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map echarge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eclipse\_magnitude}}{eclipse\_magnitude}}\label{eclipse_magnitude}

\texttt{eclipse\_magnitude} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eclipse\_magnitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eclipse\_magnitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecliptic\_obliquity}}{ecliptic\_obliquity}}\label{ecliptic_obliquity}

\texttt{ecliptic\_obliquity} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ecliptic\_obliquity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ecliptic\_obliquity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ecliptic\_to\_equatorial}}{ecliptic\_to\_equatorial}}\label{ecliptic_to_equatorial}

\texttt{ecliptic\_to\_equatorial} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ecliptic\_to\_equatorial $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{econs}}{econs}}\label{econs}

\texttt{econs} --- python/ruby stdlib builtin. Alias for
\texttt{each\_cons}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = econs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map econs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eddington\_luminosity}}{eddington\_luminosity}}\label{eddington_luminosity}

\texttt{eddington\_luminosity} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eddington\_luminosity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eddington\_luminosity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{edge\_coloring\_vizing\_step}}{edge\_coloring\_vizing\_step}}\label{edge_coloring_vizing_step}

\texttt{edge\_coloring\_vizing\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = edge\_coloring\_vizing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map edge\_coloring\_vizing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{edge\_connectivity}}{edge\_connectivity}}\label{edge_connectivity}

\texttt{edge\_connectivity} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = edge\_connectivity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map edge\_connectivity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{edge\_detect\_kernel}}{edge\_detect\_kernel}}\label{edge_detect_kernel}

\texttt{edge\_detect\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = edge\_detect\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map edge\_detect\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{edgeworth\_box\_alloc}}{edgeworth\_box\_alloc}}\label{edgeworth_box_alloc}

\texttt{edgeworth\_box\_alloc} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = edgeworth\_box\_alloc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map edgeworth\_box\_alloc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{edmonds\_karp\_bfs}}{edmonds\_karp\_bfs}}\label{edmonds_karp_bfs}

\texttt{edmonds\_karp\_bfs} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = edmonds\_karp\_bfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map edmonds\_karp\_bfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{edmonds\_karp\_step}}{edmonds\_karp\_step}}\label{edmonds_karp_step}

\texttt{edmonds\_karp\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = edmonds\_karp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map edmonds\_karp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{effect}}{effect}}\label{effect}

\texttt{effect} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = effect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map effect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{effective\_pop\_size}}{effective\_pop\_size}}\label{effective_pop_size}

\texttt{effective\_pop\_size} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = effective\_pop\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map effective\_pop\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{efficiency\_ratio}}{efficiency\_ratio}}\label{efficiency_ratio}

\texttt{efficiency\_ratio} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = efficiency\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map efficiency\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{efield}}{efield}}\label{efield}

\texttt{efield} --- physics formulas builtin. Alias for
\texttt{electric\_field}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = efield $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map efield |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{efield\_point}}{efield\_point}}\label{efield_point}

\texttt{efield\_point} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = efield\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map efield\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{egalitarian\_solution}}{egalitarian\_solution}}\label{egalitarian_solution}

\texttt{egalitarian\_solution} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = egalitarian\_solution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map egalitarian\_solution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{egalitarian\_split}}{egalitarian\_split}}\label{egalitarian_split}

\texttt{egalitarian\_split} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = egalitarian\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map egalitarian\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{egarch\_step}}{egarch\_step}}\label{egarch_step}

\texttt{egarch\_step} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = egarch\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map egarch\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eig}}{eig}}\label{eig}

\texttt{matrix\_eigenvalues} (aliases \texttt{meig}, \texttt{eig})
computes eigenvalues of a square matrix via QR iteration. Returns an
array of eigenvalues.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @eigs = @\{eig([[2,1],[1,2]])\}   \# [3, 1]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{einstein\_dilaton\_step}}{einstein\_dilaton\_step}}\label{einstein_dilaton_step}

\texttt{einstein\_dilaton\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = einstein\_dilaton\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map einstein\_dilaton\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{einstein\_ring\_radius}}{einstein\_ring\_radius}}\label{einstein_ring_radius}

\texttt{einstein\_ring\_radius} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = einstein\_ring\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map einstein\_ring\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{einstein\_tensor\_step}}{einstein\_tensor\_step}}\label{einstein_tensor_step}

\texttt{einstein\_tensor\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = einstein\_tensor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map einstein\_tensor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{either}}{either}}\label{either}

\texttt{either} --- boolean combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = either $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map either |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ekf\_jacobian\_step}}{ekf\_jacobian\_step}}\label{ekf_jacobian_step}

\texttt{ekf\_jacobian\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ekf\_jacobian\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ekf\_jacobian\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ekman\_layer\_depth}}{ekman\_layer\_depth}}\label{ekman_layer_depth}

\texttt{ekman\_layer\_depth} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ekman\_layer\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ekman\_layer\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ekman\_pumping\_step}}{ekman\_pumping\_step}}\label{ekman_pumping_step}

\texttt{ekman\_pumping\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ekman\_pumping\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ekman\_pumping\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electric\_field}}{electric\_field}}\label{electric_field}

\texttt{electric\_field} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electric\_field $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electric\_field |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrochem\_impedance\_z}}{electrochem\_impedance\_z}}\label{electrochem_impedance_z}

\texttt{electrochem\_impedance\_z} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrochem\_impedance\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrochem\_impedance\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrochemiluminescence\_yield}}{electrochemiluminescence\_yield}}\label{electrochemiluminescence_yield}

\texttt{electrochemiluminescence\_yield} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrochemiluminescence\_yield $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrochemiluminescence\_yield |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrocrystallization\_step}}{electrocrystallization\_step}}\label{electrocrystallization_step}

\texttt{electrocrystallization\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrocrystallization\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrocrystallization\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrode\_potential\_step}}{electrode\_potential\_step}}\label{electrode_potential_step}

\texttt{electrode\_potential\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrode\_potential\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrode\_potential\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrolysis\_mass}}{electrolysis\_mass}}\label{electrolysis_mass}

\texttt{electrolysis\_mass} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrolysis\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrolysis\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrolyte\_decomposition\_temp}}{electrolyte\_decomposition\_temp}}\label{electrolyte_decomposition_temp}

\texttt{electrolyte\_decomposition\_temp} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrolyte\_decomposition\_temp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrolyte\_decomposition\_temp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electrolyzer\_voltage}}{electrolyzer\_voltage}}\label{electrolyzer_voltage}

\texttt{electrolyzer\_voltage} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electrolyzer\_voltage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electrolyzer\_voltage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electron\_mass}}{electron\_mass}}\label{electron_mass}

\texttt{electron\_mass} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electron\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electron\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{electroosmotic\_velocity}}{electroosmotic\_velocity}}\label{electroosmotic_velocity}

\texttt{electroosmotic\_velocity} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = electroosmotic\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map electroosmotic\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elem\_at}}{elem\_at}}\label{elem_at}

\texttt{elem\_at} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elem\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elem\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elem\_index}}{elem\_index}}\label{elem_index}

\texttt{elem\_index} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elem\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elem\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elem\_indices}}{elem\_indices}}\label{elem_indices}

\texttt{elem\_indices} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elem\_indices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elem\_indices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elem\_of}}{elem\_of}}\label{elem_of}

\texttt{elem\_of} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elem\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elem\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elementary\_charge}}{elementary\_charge}}\label{elementary_charge}

\texttt{elementary\_charge} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elementary\_charge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elementary\_charge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elgamal\_encrypt}}{elgamal\_encrypt}}\label{elgamal_encrypt}

\texttt{elgamal\_encrypt} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elgamal\_encrypt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elgamal\_encrypt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elias\_delta\_code}}{elias\_delta\_code}}\label{elias_delta_code}

\texttt{elias\_delta\_code} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elias\_delta\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elias\_delta\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elias\_gamma\_code}}{elias\_gamma\_code}}\label{elias_gamma_code}

\texttt{elias\_gamma\_code} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elias\_gamma\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elias\_gamma\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elidx}}{elidx}}\label{elidx}

\texttt{elidx} --- additional missing stdlib functions builtin. Alias
for \texttt{elem\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elidx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elidx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elidxs}}{elidxs}}\label{elidxs}

\texttt{elidxs} --- additional missing stdlib functions builtin. Alias
for \texttt{elem\_indices}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elidxs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elidxs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellip\_lp}}{ellip\_lp}}\label{ellip_lp}

\texttt{ellip\_lp} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellip\_lp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellip\_lp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipe}}{ellipe}}\label{ellipe}

\texttt{ellipe} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellipe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellipe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipk}}{ellipk}}\label{ellipk}

\texttt{ellipk} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellipk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellipk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipperim}}{ellipperim}}\label{ellipperim}

\texttt{ellipperim} --- geometry (extended) builtin. Alias for
\texttt{ellipse\_perimeter}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellipperim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellipperim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipse\_perimeter}}{ellipse\_perimeter}}\label{ellipse_perimeter}

\texttt{ellipse\_perimeter(\$a,\ \$b)} (alias \texttt{ellper}) ---
approximates the perimeter of an ellipse with semi-axes a and b. Uses
Ramanujan\textquotesingle s approximation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ellper(5, 3)   \# \textasciitilde{}25.5}
\NormalTok{p ellper(10, 10)   \# \textasciitilde{}62.8 (circle)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipsis}}{ellipsis}}\label{ellipsis}

\texttt{ellipsis} --- string quote / escape builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellipsis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellipsis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipsoid\_surface\_approx}}{ellipsoid\_surface\_approx}}\label{ellipsoid_surface_approx}

\texttt{ellipsoid\_surface\_approx} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellipsoid\_surface\_approx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellipsoid\_surface\_approx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ellipsoid\_volume}}{ellipsoid\_volume}}\label{ellipsoid_volume}

\texttt{ellipsoid\_volume} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ellipsoid\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ellipsoid\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elo\_expected}}{elo\_expected}}\label{elo_expected}

\texttt{elo\_expected} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elo\_expected $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elo\_expected |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elo\_update}}{elo\_update}}\label{elo_update}

\texttt{elo\_update} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elo\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elo\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elof}}{elof}}\label{elof}

\texttt{elof} --- haskell list functions builtin. Alias for
\texttt{elem\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = elof $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map elof |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{elu}}{elu}}\label{elu}

\texttt{elu} applies the Exponential Linear Unit: x if x≥0,
alpha*(e\^{}x - 1) otherwise.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p elu(1)     \# 1}
\NormalTok{p elu({-}1)    \# {-}0.632}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{em\_frequency}}{em\_frequency}}\label{em_frequency}

\texttt{em\_frequency} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = em\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map em\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{em\_intensity}}{em\_intensity}}\label{em_intensity}

\texttt{em\_intensity} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = em\_intensity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map em\_intensity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{em\_step}}{em\_step}}\label{em_step}

\texttt{em\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = em\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map em\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{em\_wavelength}}{em\_wavelength}}\label{em_wavelength}

\texttt{em\_wavelength} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = em\_wavelength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map em\_wavelength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{email\_domain}}{email\_domain}}\label{email_domain}

\texttt{email\_domain} --- url / email parts builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = email\_domain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map email\_domain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{email\_local}}{email\_local}}\label{email_local}

\texttt{email\_local} --- url / email parts builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = email\_local $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map email\_local |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emass}}{emass}}\label{emass}

\texttt{emass} --- constants builtin. Alias for \texttt{electron\_mass}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emavg}}{emavg}}\label{emavg}

\texttt{emavg} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{exponential\_moving\_average}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emavg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emavg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{embed\_ts}}{embed\_ts}}\label{embed_ts}

\texttt{embed\_ts} --- time-delay embedding. Converts a time series into
a matrix of lagged values. Like R\textquotesingle s embed().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p embed\_ts([1,2,3,4,5], 3)  \# [[3,2,1],[4,3,2],[5,4,3]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emboss\_kernel}}{emboss\_kernel}}\label{emboss_kernel}

\texttt{emboss\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emboss\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emboss\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emf\_from\_half\_cells}}{emf\_from\_half\_cells}}\label{emf_from_half_cells}

\texttt{emf\_from\_half\_cells} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emf\_from\_half\_cells $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emf\_from\_half\_cells |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emissivity\_grey\_body}}{emissivity\_grey\_body}}\label{emissivity_grey_body}

\texttt{emissivity\_grey\_body} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emissivity\_grey\_body $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emissivity\_grey\_body |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emitted\_long\_wave}}{emitted\_long\_wave}}\label{emitted_long_wave}

\texttt{emitted\_long\_wave} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emitted\_long\_wave $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emitted\_long\_wave |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{emojinum}}{emojinum}}\label{emojinum}

\texttt{emojinum} --- encoding / phonetics builtin. Alias for
\texttt{to\_emoji\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = emojinum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map emojinum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{empc}}{empc}}\label{empc}

\texttt{empc} --- algebraic match builtin. Alias for
\texttt{empty\_clj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = empc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map empc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{empty\_clj}}{empty\_clj}}\label{empty_clj}

\texttt{empty\_clj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = empty\_clj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map empty\_clj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{empty\_count}}{empty\_count}}\label{empty_count}

\texttt{empty\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = empty\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map empty\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{encode\_base}}{encode\_base}}\label{encode_base}

\texttt{encode\_base} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = encode\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map encode\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{encode\_pair}}{encode\_pair}}\label{encode_pair}

\texttt{encode\_pair} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = encode\_pair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map encode\_pair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{encode\_succ}}{encode\_succ}}\label{encode_succ}

\texttt{encode\_succ} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = encode\_succ $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map encode\_succ |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{end\_of\_day}}{end\_of\_day}}\label{end_of_day}

\texttt{end\_of\_day} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = end\_of\_day $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map end\_of\_day |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endgrent}}{endgrent}}\label{endgrent}

\texttt{endgrent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endgrent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endgrent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endhostent}}{endhostent}}\label{endhostent}

\texttt{endhostent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endhostent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endhostent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endianness}}{endianness}}\label{endianness}

\texttt{endianness} --- byte order of the platform: \texttt{"little"} or
\texttt{"big"}. Compile-time constant.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p endianness                             \# little}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endnetent}}{endnetent}}\label{endnetent}

\texttt{endnetent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endnetent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endnetent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endowment\_combined\_a}}{endowment\_combined\_a}}\label{endowment_combined_a}

\texttt{endowment\_combined\_a} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endowment\_combined\_a $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endowment\_combined\_a |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endowment\_pure\_e}}{endowment\_pure\_e}}\label{endowment_pure_e}

\texttt{endowment\_pure\_e} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endowment\_pure\_e $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endowment\_pure\_e |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endprotoent}}{endprotoent}}\label{endprotoent}

\texttt{endprotoent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endprotoent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endprotoent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endpwent}}{endpwent}}\label{endpwent}

\texttt{endpwent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endpwent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endpwent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ends\_with}}{ends\_with}}\label{ends_with}

\texttt{ends\_with} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ends\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ends\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ends\_with\_any}}{ends\_with\_any}}\label{ends_with_any}

\texttt{ends\_with\_any} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ends\_with\_any $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ends\_with\_any |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{endservent}}{endservent}}\label{endservent}

\texttt{endservent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = endservent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map endservent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{energy}}{energy}}\label{energy}

\texttt{energy(\textbackslash{}@signal)} --- computes the total energy
of a signal as the sum of squared samples. Useful for audio analysis and
feature extraction.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p energy(\textbackslash{}@signal)   \# total signal energy}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{energy\_density\_battery}}{energy\_density\_battery}}\label{energy_density_battery}

\texttt{energy\_density\_battery} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = energy\_density\_battery $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map energy\_density\_battery |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{energy\_efficiency\_cell}}{energy\_efficiency\_cell}}\label{energy_efficiency_cell}

\texttt{energy\_efficiency\_cell} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = energy\_efficiency\_cell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map energy\_efficiency\_cell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{engel\_curve}}{engel\_curve}}\label{engel_curve}

\texttt{engel\_curve} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = engel\_curve $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map engel\_curve |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{engle\_granger\_step}}{engle\_granger\_step}}\label{engle_granger_step}

\texttt{engle\_granger\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = engle\_granger\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map engle\_granger\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{english\_auction}}{english\_auction}}\label{english_auction}

\texttt{english\_auction} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = english\_auction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map english\_auction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{english\_auction\_step}}{english\_auction\_step}}\label{english_auction_step}

\texttt{english\_auction\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = english\_auction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map english\_auction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{english\_chi2}}{english\_chi2}}\label{english_chi2}

\texttt{english\_chi2} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = english\_chi2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map english\_chi2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{english\_likeness}}{english\_likeness}}\label{english_likeness}

\texttt{english\_likeness} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = english\_likeness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map english\_likeness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{enso\_index\_step}}{enso\_index\_step}}\label{enso_index_step}

\texttt{enso\_index\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = enso\_index\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map enso\_index\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ensure\_prefix}}{ensure\_prefix}}\label{ensure_prefix}

\texttt{ensure\_prefix} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ensure\_prefix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ensure\_prefix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ensure\_suffix}}{ensure\_suffix}}\label{ensure_suffix}

\texttt{ensure\_suffix} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ensure\_suffix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ensure\_suffix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{entanglement\_entropy}}{entanglement\_entropy}}\label{entanglement_entropy}

\texttt{entanglement\_entropy} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = entanglement\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map entanglement\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{enthalpy\_reaction}}{enthalpy\_reaction}}\label{enthalpy_reaction}

\texttt{enthalpy\_reaction} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = enthalpy\_reaction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map enthalpy\_reaction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{entropy}}{entropy}}\label{entropy}

\texttt{entropy} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{entropy\_bits}}{entropy\_bits}}\label{entropy_bits}

\texttt{entropy\_bits} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = entropy\_bits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map entropy\_bits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env}}{env}}\label{env}

\texttt{env} --- dsp / signal (extended) builtin. Alias for
\texttt{envelope}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env\_get}}{env\_get}}\label{env_get}

\texttt{env\_get} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env\_get $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env\_get |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env\_has}}{env\_has}}\label{env_has}

\texttt{env\_has} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env\_has $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env\_has |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env\_keys}}{env\_keys}}\label{env_keys}

\texttt{env\_keys} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env\_pairs}}{env\_pairs}}\label{env_pairs}

\texttt{env\_pairs} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env\_remove}}{env\_remove}}\label{env_remove}

\texttt{env\_remove} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env\_remove $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env\_remove |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{env\_set}}{env\_set}}\label{env_set}

\texttt{env\_set} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = env\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map env\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{envelope}}{envelope}}\label{envelope}

\texttt{envelope(\textbackslash{}@signal)} (alias \texttt{hilbert\_env})
--- computes the amplitude envelope using Hilbert transform magnitude.
Useful for amplitude modulation analysis.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $env = envelope(\textbackslash{}@signal)}
\NormalTok{\# $env traces the amplitude of oscillations}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{envelope\_amplitude}}{envelope\_amplitude}}\label{envelope_amplitude}

\texttt{envelope\_amplitude} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = envelope\_amplitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map envelope\_amplitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eod}}{eod}}\label{eod}

\texttt{eod} --- extended stdlib builtin. Alias for
\texttt{end\_of\_day}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eof\_from\_concurrence}}{eof\_from\_concurrence}}\label{eof_from_concurrence}

\texttt{eof\_from\_concurrence} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eof\_from\_concurrence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eof\_from\_concurrence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epa\_per\_play}}{epa\_per\_play}}\label{epa_per_play}

\texttt{epa\_per\_play} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = epa\_per\_play $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map epa\_per\_play |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epoch}}{epoch}}\label{epoch}

\texttt{epoch} --- now / timestamp builtin. Alias for
\texttt{unix\_epoch}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = epoch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map epoch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epoch\_ms}}{epoch\_ms}}\label{epoch_ms}

\texttt{epoch\_ms} --- now / timestamp builtin. Alias for
\texttt{unix\_epoch\_ms}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = epoch\_ms $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map epoch\_ms |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epotential\_point}}{epotential\_point}}\label{epotential_point}

\texttt{epotential\_point} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = epotential\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map epotential\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eps}}{eps}}\label{eps}

\texttt{eps} --- math / numeric (uncategorized batch) builtin. Alias for
\texttt{epsilon}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eps $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eps |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epsilon}}{epsilon}}\label{epsilon}

\texttt{epsilon} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = epsilon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map epsilon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epsilon0}}{epsilon0}}\label{epsilon0}

\texttt{vacuum\_permittivity} (alias \texttt{epsilon0}) --- ε₀ ≈
8.854×10⁻¹² F/m. Electric constant, permittivity of free space.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p epsilon0   \# 8.8541878128e{-}12}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{epsilon\_extinction}}{epsilon\_extinction}}\label{epsilon_extinction}

\texttt{epsilon\_extinction} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = epsilon\_extinction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map epsilon\_extinction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eqidx}}{eqidx}}\label{eqidx}

\texttt{eqidx} --- extended stdlib batch 3 builtin. Alias for
\texttt{equilibrium\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eqidx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eqidx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eqrng}}{eqrng}}\label{eqrng}

\texttt{eqrng} --- extended stdlib builtin. Alias for
\texttt{equal\_range}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eqrng $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eqrng |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equal\_range}}{equal\_range}}\label{equal_range}

\texttt{equal\_range} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equal\_range $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equal\_range |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equal\_tempered\_freq}}{equal\_tempered\_freq}}\label{equal_tempered_freq}

\texttt{equal\_tempered\_freq} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equal\_tempered\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equal\_tempered\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equation\_of\_time}}{equation\_of\_time}}\label{equation_of_time}

\texttt{equation\_of\_time} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equation\_of\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equation\_of\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equatorial\_to\_galactic}}{equatorial\_to\_galactic}}\label{equatorial_to_galactic}

\texttt{equatorial\_to\_galactic} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equatorial\_to\_galactic $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equilibrium\_index}}{equilibrium\_index}}\label{equilibrium_index}

\texttt{equilibrium\_index} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equilibrium\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equilibrium\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equinox\_spring}}{equinox\_spring}}\label{equinox_spring}

\texttt{equinox\_spring} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equinox\_spring $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equinox\_spring |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equirectangular\_project}}{equirectangular\_project}}\label{equirectangular_project}

\texttt{equirectangular\_project} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equirectangular\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equirectangular\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{equivalent\_potential\_temp}}{equivalent\_potential\_temp}}\label{equivalent_potential_temp}

\texttt{equivalent\_potential\_temp} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = equivalent\_potential\_temp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map equivalent\_potential\_temp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{era\_plus}}{era\_plus}}\label{era_plus}

\texttt{era\_plus} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = era\_plus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map era\_plus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{erf\_approx}}{erf\_approx}}\label{erf_approx}

\texttt{erf\_approx(\$x)} --- error function. Used in probability,
statistics, and partial differential equations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p erf(1)    \# \textasciitilde{}0.843}
\NormalTok{p erf(2)    \# \textasciitilde{}0.995}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{erfcx}}{erfcx}}\label{erfcx}

\texttt{erfcx} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = erfcx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map erfcx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{erfi}}{erfi}}\label{erfi}

\texttt{erfi} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = erfi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map erfi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{error\_correction\_step}}{error\_correction\_step}}\label{error_correction_step}

\texttt{error\_correction\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = error\_correction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map error\_correction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ertel\_pv\_step}}{ertel\_pv\_step}}\label{ertel_pv_step}

\texttt{ertel\_pv\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ertel\_pv\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ertel\_pv\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{escape\_json}}{escape\_json}}\label{escape_json}

\texttt{escape\_json} --- json helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = escape\_json $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map escape\_json |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{escape\_velocity}}{escape\_velocity}}\label{escape_velocity}

\texttt{escape\_velocity(\$mass,\ \$radius)} (alias \texttt{escvel}) ---
minimum velocity to escape gravitational field: v = √(2GM/r). Defaults
to Earth values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p escvel                        \# \textasciitilde{}11186 m/s (Earth)}
\NormalTok{p escvel(1.989e30, 6.96e8)      \# \textasciitilde{}617 km/s (Sun)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{escape\_velocity\_body}}{escape\_velocity\_body}}\label{escape_velocity_body}

\texttt{escape\_velocity\_body} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = escape\_velocity\_body $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map escape\_velocity\_body |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eslice}}{eslice}}\label{eslice}

\texttt{eslice} --- python/ruby stdlib builtin. Alias for
\texttt{each\_slice}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eslice $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eslice |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{et\_freq\_ratio}}{et\_freq\_ratio}}\label{et_freq_ratio}

\texttt{et\_freq\_ratio} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = et\_freq\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map et\_freq\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{etag\_validate}}{etag\_validate}}\label{etag_validate}

\texttt{etag\_validate} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = etag\_validate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map etag\_validate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{etd\_rk2}}{etd\_rk2}}\label{etd_rk2}

\texttt{etd\_rk2} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = etd\_rk2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map etd\_rk2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eth\_addr\_check}}{eth\_addr\_check}}\label{eth_addr_check}

\texttt{eth\_addr\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eth\_addr\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eth\_addr\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ethiopic\_from\_fixed}}{ethiopic\_from\_fixed}}\label{ethiopic_from_fixed}

\texttt{ethiopic\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ethiopic\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ethiopic\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{etot}}{etot}}\label{etot}

\texttt{etot} --- extended stdlib batch 3 builtin. Alias for
\texttt{euler\_totient}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = etot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map etot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eucdist}}{eucdist}}\label{eucdist}

\texttt{eucdist} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{euclidean\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eucdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eucdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euclidean\_distance}}{euclidean\_distance}}\label{euclidean_distance}

\texttt{euclidean\_distance} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euclidean\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euclidean\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euclidean\_distance\_nd}}{euclidean\_distance\_nd}}\label{euclidean_distance_nd}

\texttt{euclidean\_distance\_nd} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euclidean\_distance\_nd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euclidean\_distance\_nd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_char\_complex}}{euler\_char\_complex}}\label{euler_char_complex}

\texttt{euler\_char\_complex} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euler\_char\_complex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euler\_char\_complex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_characteristic}}{euler\_characteristic}}\label{euler_characteristic}

\texttt{euler\_characteristic} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euler\_characteristic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euler\_characteristic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_e}}{euler\_e}}\label{euler_e}

\texttt{euler\_e} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{euler\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euler\_e $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euler\_e |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_lte}}{euler\_lte}}\label{euler_lte}

\texttt{euler\_lte} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euler\_lte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euler\_lte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_mascheroni}}{euler\_mascheroni}}\label{euler_mascheroni}

\texttt{euler\_mascheroni} (alias \texttt{gamma\_const}) ---
Euler-Mascheroni constant γ ≈ 0.5772. Appears in number theory and
analysis.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p euler\_mascheroni   \# 0.5772156649015329}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_method}}{euler\_method}}\label{euler_method}

\texttt{euler\_ode} (alias \texttt{euler\_method}) solves an ODE dy/dt =
f(t,y) using the Euler method. Returns {[}{[}t,y{]}, ...{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $sol = euler\_ode(fn \{ $\_[1] \}, 0, 1, 0.01, 100)  \# exponential growth}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_number}}{euler\_number}}\label{euler_number}

\texttt{euler\_number} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euler\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euler\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{euler\_totient}}{euler\_totient}}\label{euler_totient}

\texttt{euler\_totient} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = euler\_totient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map euler\_totient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eulerian\_path\_q}}{eulerian\_path\_q}}\label{eulerian_path_q}

\texttt{eulerian\_path\_q} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eulerian\_path\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eulerian\_path\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ev\_to\_joules}}{ev\_to\_joules}}\label{ev_to_joules}

\texttt{ev\_to\_joules} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ev\_to\_joules $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eval\_rpn}}{eval\_rpn}}\label{eval_rpn}

\texttt{eval\_rpn} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eval\_rpn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eval\_rpn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{even}}{even}}\label{even}

\texttt{even} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = even $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map even |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{event\_horizon\_check}}{event\_horizon\_check}}\label{event_horizon_check}

\texttt{event\_horizon\_check} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = event\_horizon\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map event\_horizon\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{every\_nth}}{every\_nth}}\label{every_nth}

\texttt{every\_nth} --- collection helpers (trivial) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = every\_nth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map every\_nth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{evolutionary\_stable\_strategy}}{evolutionary\_stable\_strategy}}\label{evolutionary_stable_strategy}

\texttt{evolutionary\_stable\_strategy} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = evolutionary\_stable\_strategy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map evolutionary\_stable\_strategy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ew}}{ew}}\label{ew}

\texttt{ew} --- trivial string ops builtin. Alias for
\texttt{ends\_with}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ew $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ew |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ewma\_smooth}}{ewma\_smooth}}\label{ewma_smooth}

\texttt{ewma\_smooth} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ewma\_smooth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ewma\_smooth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ewo}}{ewo}}\label{ewo}

\texttt{ewo} --- additional missing stdlib functions builtin. Alias for
\texttt{each\_with\_object}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ewo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ewo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ex\_ante\_value\_check}}{ex\_ante\_value\_check}}\label{ex_ante_value_check}

\texttt{ex\_ante\_value\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ex\_ante\_value\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ex\_ante\_value\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ex\_post\_value\_check}}{ex\_post\_value\_check}}\label{ex_post_value_check}

\texttt{ex\_post\_value\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ex\_post\_value\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ex\_post\_value\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exchange\_current\_density}}{exchange\_current\_density}}\label{exchange_current_density}

\texttt{exchange\_current\_density} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exchange\_current\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exchange\_current\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exe}}{exe}}\label{exe}

\texttt{exe} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{executables}}{executables}}\label{executables}

\texttt{executables} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = executables $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map executables |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exists\_key}}{exists\_key}}\label{exists_key}

\texttt{exists\_key} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exists\_key $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exists\_key |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp2}}{exp2}}\label{exp2}

\texttt{exp2} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exp2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exp2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp\_euler\_step}}{exp\_euler\_step}}\label{exp_euler_step}

\texttt{exp\_euler\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exp\_euler\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exp\_euler\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp\_golomb\_code}}{exp\_golomb\_code}}\label{exp_golomb_code}

\texttt{exp\_golomb\_code} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exp\_golomb\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exp\_golomb\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp\_integral\_e1}}{exp\_integral\_e1}}\label{exp_integral_e1}

\texttt{exp\_integral\_e1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exp\_integral\_e1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exp\_integral\_e1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp\_smooth\_double}}{exp\_smooth\_double}}\label{exp_smooth_double}

\texttt{exp\_smooth\_double} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exp\_smooth\_double $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exp\_smooth\_double |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exp\_smooth\_simple}}{exp\_smooth\_simple}}\label{exp_smooth_simple}

\texttt{exp\_smooth\_simple} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exp\_smooth\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exp\_smooth\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{expansion\_scalar\_step}}{expansion\_scalar\_step}}\label{expansion_scalar_step}

\texttt{expansion\_scalar\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = expansion\_scalar\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map expansion\_scalar\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{expected\_coverage}}{expected\_coverage}}\label{expected_coverage}

\texttt{expected\_coverage} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = expected\_coverage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map expected\_coverage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{expenditure\_function}}{expenditure\_function}}\label{expenditure_function}

\texttt{expenditure\_function} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = expenditure\_function $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map expenditure\_function |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{experience\_factor}}{experience\_factor}}\label{experience_factor}

\texttt{experience\_factor} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = experience\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map experience\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{expire}}{expire}}\label{expire}

\texttt{expire} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = expire $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map expire |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{explore\_exploit\_epsilon}}{explore\_exploit\_epsilon}}\label{explore_exploit_epsilon}

\texttt{explore\_exploit\_epsilon} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = explore\_exploit\_epsilon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map explore\_exploit\_epsilon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exponential\_moving\_average}}{exponential\_moving\_average}}\label{exponential_moving_average}

\texttt{exponential\_moving\_average} --- math / numeric (uncategorized
batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exponential\_moving\_average $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exponential\_moving\_average |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exponential\_pdf}}{exponential\_pdf}}\label{exponential_pdf}

\texttt{exponential\_pdf} --- math formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exponential\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exponential\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{exppdf}}{exppdf}}\label{exppdf}

\texttt{exppdf} --- math formulas builtin. Alias for
\texttt{exponential\_pdf}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exppdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exppdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{extends}}{extends}}\label{extends}

\texttt{extends} specifies parent classes for inheritance. Child classes
inherit all fields and methods from parents.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Animal \{ name: Str \}}
\NormalTok{class Dog extends Animal \{ breed: Str \}}
\NormalTok{class Hybrid extends Dog, Cat \{ \}  \# multiple inheritance}
\end{Highlighting}
\end{Shaded}

Inherited fields appear first in construction order. Methods are
resolved child-first (override pattern).

\section{\texorpdfstring{\texttt{exterior\_derivative\_one\_form}}{exterior\_derivative\_one\_form}}\label{exterior_derivative_one_form}

\texttt{exterior\_derivative\_one\_form} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = exterior\_derivative\_one\_form $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map exterior\_derivative\_one\_form |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{extract\_between}}{extract\_between}}\label{extract_between}

\texttt{extract\_between} --- string quote / escape builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = extract\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map extract\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{extrinsic\_principal\_curv}}{extrinsic\_principal\_curv}}\label{extrinsic_principal_curv}

\texttt{extrinsic\_principal\_curv} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = extrinsic\_principal\_curv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map extrinsic\_principal\_curv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eye}}{eye}}\label{eye}

\texttt{eye} --- matrix / linear algebra builtin. Alias for
\texttt{identity\_matrix}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eye $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eye |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eyring\_k}}{eyring\_k}}\label{eyring_k}

\texttt{eyring\_k} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eyring\_k $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eyring\_k |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{eyring\_rate}}{eyring\_rate}}\label{eyring_rate}

\texttt{eyring\_rate} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = eyring\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map eyring\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f}}{f}}\label{f}

\texttt{f} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map f |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f64\_max}}{f64\_max}}\label{f64_max}

\texttt{f64\_max} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f64\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map f64\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f64\_min}}{f64\_min}}\label{f64_min}

\texttt{f64\_min} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f64\_min $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map f64\_min |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f\_beta}}{f\_beta}}\label{f_beta}

\texttt{f\_beta} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f\_beta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map f\_beta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f\_pdf}}{f\_pdf}}\label{f_pdf}

\texttt{f\_pdf} (alias \texttt{fpdf}) evaluates the F-distribution PDF
at x with d1 and d2 degrees of freedom.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p fpdf(1.0, 5, 10)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f\_statistic\_pooled}}{f\_statistic\_pooled}}\label{f_statistic_pooled}

\texttt{f\_statistic\_pooled} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f\_statistic\_pooled $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map f\_statistic\_pooled |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f\_to\_c}}{f\_to\_c}}\label{f_to_c}

\texttt{f\_to\_c} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f\_to\_c $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{f\_to\_k}}{f\_to\_k}}\label{f_to_k}

\texttt{f\_to\_k} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = f\_to\_k $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{face\_detect\_haar}}{face\_detect\_haar}}\label{face_detect_haar}

\texttt{face\_detect\_haar} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = face\_detect\_haar $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map face\_detect\_haar |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fact}}{fact}}\label{fact}

\texttt{fact} --- trivial numeric / predicate builtins builtin. Alias
for \texttt{factorial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{factorial}}{factorial}}\label{factorial}

\texttt{factorial} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = factorial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map factorial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{factorial2}}{factorial2}}\label{factorial2}

\texttt{factorial2} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = factorial2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map factorial2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{factorialk}}{factorialk}}\label{factorialk}

\texttt{factorialk} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = factorialk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map factorialk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{faf}}{faf}}\label{faf}

\texttt{faf} --- stress testing builtin. Alias for
\texttt{fire\_and\_forget}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = faf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map faf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fair\_division\_envy\_free}}{fair\_division\_envy\_free}}\label{fair_division_envy_free}

\texttt{fair\_division\_envy\_free} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fair\_division\_envy\_free $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fair\_division\_envy\_free |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{falf}}{falf}}\label{falf}

\texttt{falf} --- python/ruby stdlib builtin. Alias for
\texttt{filterfalse}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = falf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map falf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fallback}}{fallback}}\label{fallback}

\texttt{fallback} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fallback $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fallback |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{falling\_factorial}}{falling\_factorial}}\label{falling_factorial}

\texttt{falling\_factorial} --- math formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = falling\_factorial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map falling\_factorial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{false\_position}}{false\_position}}\label{false_position}

\texttt{false\_position} --- batch 19 builtin. Alias for
\texttt{regula\_falsi}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = false\_position $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map false\_position |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{falsy\_count}}{falsy\_count}}\label{falsy_count}

\texttt{falsy\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = falsy\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map falsy\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fano\_inequality\_bound}}{fano\_inequality\_bound}}\label{fano_inequality_bound}

\texttt{fano\_inequality\_bound} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fano\_inequality\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fano\_inequality\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{faradaic\_efficiency}}{faradaic\_efficiency}}\label{faradaic_efficiency}

\texttt{faradaic\_efficiency} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = faradaic\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map faradaic\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{faraday}}{faraday}}\label{faraday}

\texttt{faraday\_constant} (alias \texttt{faraday}) --- F ≈ 96485 C/mol.
Charge per mole of electrons.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p faraday   \# 96485.33212}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{faraday\_efficiency\_h2}}{faraday\_efficiency\_h2}}\label{faraday_efficiency_h2}

\texttt{faraday\_efficiency\_h2} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = faraday\_efficiency\_h2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map faraday\_efficiency\_h2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{faraday\_emf}}{faraday\_emf}}\label{faraday_emf}

\texttt{faraday\_emf} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = faraday\_emf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map faraday\_emf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{faraday\_mass\_deposited}}{faraday\_mass\_deposited}}\label{faraday_mass_deposited}

\texttt{faraday\_mass\_deposited} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = faraday\_mass\_deposited $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map faraday\_mass\_deposited |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{farmhash\_64}}{farmhash\_64}}\label{farmhash_64}

\texttt{farmhash\_64} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = farmhash\_64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map farmhash\_64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{farthest\_insertion\_step}}{farthest\_insertion\_step}}\label{farthest_insertion_step}

\texttt{farthest\_insertion\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = farthest\_insertion\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map farthest\_insertion\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fb}}{fb}}\label{fb}

\texttt{fb} --- algorithms / puzzles builtin. Alias for
\texttt{fizzbuzz}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fcntl}}{fcntl}}\label{fcntl}

\texttt{fcntl} --- ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fcntl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fcntl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fcp}}{fcp}}\label{fcp}

\texttt{fcp} --- extended stdlib builtin. Alias for
\texttt{from\_code\_point}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fcp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fcp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fdivop}}{fdivop}}\label{fdivop}

\texttt{fdivop} --- extended stdlib builtin. Alias for
\texttt{floor\_div\_op}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fdivop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fdivop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{feet\_to\_m}}{feet\_to\_m}}\label{feet_to_m}

\texttt{feet\_to\_m} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = feet\_to\_m $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{feet\_to\_meters}}{feet\_to\_meters}}\label{feet_to_meters}

\texttt{feet\_to\_meters} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = feet\_to\_meters $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{feiga}}{feiga}}\label{feiga}

\texttt{feiga} --- math constants builtin. Alias for
\texttt{feigenbaum\_alpha}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = feiga $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map feiga |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{feigd}}{feigd}}\label{feigd}

\texttt{feigenbaum\_delta} (alias \texttt{feigd}) --- Feigenbaum
constant δ ≈ 4.669. Universal constant in chaos theory.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p feigd   \# 4.669201609102990}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{feigenbaum\_alpha}}{feigenbaum\_alpha}}\label{feigenbaum_alpha}

\texttt{feigenbaum\_alpha} --- math constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = feigenbaum\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map feigenbaum\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{feldspar\_classify}}{feldspar\_classify}}\label{feldspar_classify}

\texttt{feldspar\_classify} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = feldspar\_classify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map feldspar\_classify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{felsenstein\_step}}{felsenstein\_step}}\label{felsenstein_step}

\texttt{felsenstein\_step} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = felsenstein\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map felsenstein\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{felzenszwalb\_segment}}{felzenszwalb\_segment}}\label{felzenszwalb_segment}

\texttt{felzenszwalb\_segment} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = felzenszwalb\_segment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map felzenszwalb\_segment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fenwick\_build}}{fenwick\_build}}\label{fenwick_build}

\texttt{fenwick\_build} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fenwick\_build $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fenwick\_build |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fenwick\_for}}{fenwick\_for}}\label{fenwick_for}

\texttt{fenwick\_for} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fenwick\_for $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fenwick\_for |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fenwick\_query}}{fenwick\_query}}\label{fenwick_query}

\texttt{fenwick\_query} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fenwick\_query $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fenwick\_query |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fermat\_factor}}{fermat\_factor}}\label{fermat_factor}

\texttt{fermat\_factor} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fermat\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fermat\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fermi\_dirac\_int}}{fermi\_dirac\_int}}\label{fermi_dirac_int}

\texttt{fermi\_dirac\_int} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fermi\_dirac\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fermi\_dirac\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fermi\_golden\_rule}}{fermi\_golden\_rule}}\label{fermi_golden_rule}

\texttt{fermi\_golden\_rule} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fermi\_golden\_rule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fermi\_golden\_rule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fermi\_normal\_step}}{fermi\_normal\_step}}\label{fermi_normal_step}

\texttt{fermi\_normal\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fermi\_normal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fermi\_normal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ferrel\_cell\_step}}{ferrel\_cell\_step}}\label{ferrel_cell_step}

\texttt{ferrel\_cell\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ferrel\_cell\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ferrel\_cell\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fetch\_val}}{fetch\_val}}\label{fetch_val}

\texttt{fetch\_val} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fetch\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fetch\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ffact}}{ffact}}\label{ffact}

\texttt{ffact} --- math formulas builtin. Alias for
\texttt{falling\_factorial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ffact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ffact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ffirst}}{ffirst}}\label{ffirst}

\texttt{ffirst} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ffirst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ffirst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ffs}}{ffs}}\label{ffs}

\texttt{ffs} --- algebraic match builtin. Alias for \texttt{ffirst}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fft\_magnitude}}{fft\_magnitude}}\label{fft_magnitude}

\texttt{fft\_magnitude} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fft\_magnitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fft\_magnitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fftconvolve\_step}}{fftconvolve\_step}}\label{fftconvolve_step}

\texttt{fftconvolve\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fftconvolve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fftconvolve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fftmag}}{fftmag}}\label{fftmag}

\texttt{fftmag} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{fft\_magnitude}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fftmag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fftmag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fib}}{fib}}\label{fib}

\texttt{fib} --- trivial numeric / predicate builtins builtin. Alias for
\texttt{fibonacci}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fib $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fib |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fibonacci}}{fibonacci}}\label{fibonacci}

\texttt{fibonacci} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fibonacci $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fibonacci |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fibonacci\_code}}{fibonacci\_code}}\label{fibonacci_code}

\texttt{fibonacci\_code} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fibonacci\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fibonacci\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fibonacci\_seq}}{fibonacci\_seq}}\label{fibonacci_seq}

\texttt{fibonacci\_seq} --- sequences builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fibonacci\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fibonacci\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fibonacci\_word}}{fibonacci\_word}}\label{fibonacci_word}

\texttt{fibonacci\_word} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fibonacci\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fibonacci\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fictitious\_play\_step}}{fictitious\_play\_step}}\label{fictitious_play_step}

\texttt{fictitious\_play\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fictitious\_play\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fictitious\_play\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fidelity\_pure\_real}}{fidelity\_pure\_real}}\label{fidelity_pure_real}

\texttt{fidelity\_pure\_real} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fidelity\_pure\_real $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fidelity\_pure\_real |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fidx}}{fidx}}\label{fidx}

\texttt{fidx} --- python/ruby stdlib builtin. Alias for
\texttt{find\_index\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fidx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fidx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{file\_atime}}{file\_atime}}\label{file_atime}

\texttt{file\_atime} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = file\_atime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map file\_atime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{file\_ctime}}{file\_ctime}}\label{file_ctime}

\texttt{file\_ctime} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = file\_ctime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map file\_ctime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{file\_mtime}}{file\_mtime}}\label{file_mtime}

\texttt{file\_mtime} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = file\_mtime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map file\_mtime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{file\_size}}{file\_size}}\label{file_size}

\texttt{file\_size} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = file\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map file\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{files}}{files}}\label{files}

\texttt{files} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = files $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map files |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filesf}}{filesf}}\label{filesf}

\texttt{filesf} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filesf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filesf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fill\_arr}}{fill\_arr}}\label{fill_arr}

\texttt{fill\_arr} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fill\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fill\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filla}}{filla}}\label{filla}

\texttt{filla} --- javascript array/object methods builtin. Alias for
\texttt{fill\_arr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filla $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filla |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_bilateral}}{filter\_bilateral}}\label{filter_bilateral}

\texttt{filter\_bilateral} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filter\_bilateral $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filter\_bilateral |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_chars}}{filter\_chars}}\label{filter_chars}

\texttt{filter\_chars} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filter\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filter\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_indexed}}{filter\_indexed}}\label{filter_indexed}

\texttt{filter\_indexed} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filter\_indexed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filter\_indexed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_map}}{filter\_map}}\label{filter_map}

\texttt{filter\_map} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filter\_map $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filter\_map |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_median}}{filter\_median}}\label{filter_median}

\texttt{filter\_median} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filter\_median $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filter\_median |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_nlmeans}}{filter\_nlmeans}}\label{filter_nlmeans}

\texttt{filter\_nlmeans} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filter\_nlmeans $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filter\_nlmeans |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filter\_ts}}{filter\_ts}}\label{filter_ts}

\texttt{ts\_filter} --- linear convolution filter. Like
R\textquotesingle s
filter(method=\textquotesingle convolution\textquotesingle).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @smooth = @\{ts\_filter([1,5,2,8,3], [0.25,0.5,0.25])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filterfalse}}{filterfalse}}\label{filterfalse}

\texttt{filterfalse} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filterfalse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filterfalse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{filtfilt\_pad}}{filtfilt\_pad}}\label{filtfilt_pad}

\texttt{filtfilt\_pad} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = filtfilt\_pad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map filtfilt\_pad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find}}{find}}\label{find}

\texttt{find} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{findInterval}}{findInterval}}\label{findinterval}

\texttt{find\_interval} --- for each x, find which interval in breaks it
falls into. Like R\textquotesingle s findInterval().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p findInterval([1.5, 3.5, 7.5], [0, 2, 5, 10])  \# [1, 2, 3]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_all}}{find\_all}}\label{find_all}

\texttt{find\_all} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_all\_indices}}{find\_all\_indices}}\label{find_all_indices}

\texttt{find\_all\_indices} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_all\_indices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_all\_indices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_first}}{find\_first}}\label{find_first}

\texttt{find\_first} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_index}}{find\_index}}\label{find_index}

\texttt{find\_index} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_index\_fn}}{find\_index\_fn}}\label{find_index_fn}

\texttt{find\_index\_fn} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_index\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_index\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_indices}}{find\_indices}}\label{find_indices}

\texttt{find\_indices} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_indices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_indices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_last}}{find\_last}}\label{find_last}

\texttt{find\_last} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_last\_index}}{find\_last\_index}}\label{find_last_index}

\texttt{find\_last\_index} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_last\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_last\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{find\_map}}{find\_map}}\label{find_map}

\texttt{find\_map} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = find\_map $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map find\_map |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{finite\_rate\_lambda}}{finite\_rate\_lambda}}\label{finite_rate_lambda}

\texttt{finite\_rate\_lambda} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = finite\_rate\_lambda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map finite\_rate\_lambda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fintushel\_stern\_step}}{fintushel\_stern\_step}}\label{fintushel_stern_step}

\texttt{fintushel\_stern\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fintushel\_stern\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fintushel\_stern\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fip}}{fip}}\label{fip}

\texttt{fip} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fir\_lowpass\_design}}{fir\_lowpass\_design}}\label{fir_lowpass_design}

\texttt{fir\_lowpass\_design} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fir\_lowpass\_design $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fir\_lowpass\_design |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fir\_moving\_average}}{fir\_moving\_average}}\label{fir_moving_average}

\texttt{fir\_moving\_average} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fir\_moving\_average $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fir\_moving\_average |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fire}}{fire}}\label{fire}

\texttt{fire} --- stress testing builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fire $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fire |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fire\_and\_forget}}{fire\_and\_forget}}\label{fire_and_forget}

\texttt{fire\_and\_forget} --- stress testing builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fire\_and\_forget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fire\_and\_forget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_arg}}{first\_arg}}\label{first_arg}

\texttt{first\_arg} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_arg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_arg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_elem}}{first\_elem}}\label{first_elem}

\texttt{first\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_eq}}{first\_eq}}\label{first_eq}

\texttt{first\_eq} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_of\_month}}{first\_of\_month}}\label{first_of_month}

\texttt{first\_of\_month} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_of\_month $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_of\_month |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_order\_concentration}}{first\_order\_concentration}}\label{first_order_concentration}

\texttt{first\_order\_concentration} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_order\_concentration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_order\_concentration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_order\_half\_life}}{first\_order\_half\_life}}\label{first_order_half_life}

\texttt{first\_order\_half\_life} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_order\_half\_life $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_order\_half\_life |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_price\_seal}}{first\_price\_seal}}\label{first_price_seal}

\texttt{first\_price\_seal} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_price\_seal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_price\_seal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{first\_word}}{first\_word}}\label{first_word}

\texttt{first\_word} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = first\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map first\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{firwin2\_freq}}{firwin2\_freq}}\label{firwin2_freq}

\texttt{firwin2\_freq} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = firwin2\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map firwin2\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{firwin\_bandpass}}{firwin\_bandpass}}\label{firwin_bandpass}

\texttt{firwin\_bandpass} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = firwin\_bandpass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map firwin\_bandpass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{firwin\_bandstop}}{firwin\_bandstop}}\label{firwin_bandstop}

\texttt{firwin\_bandstop} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = firwin\_bandstop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map firwin\_bandstop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{firwin\_highpass}}{firwin\_highpass}}\label{firwin_highpass}

\texttt{firwin\_highpass} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = firwin\_highpass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map firwin\_highpass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{firwin\_lowpass}}{firwin\_lowpass}}\label{firwin_lowpass}

\texttt{firwin\_lowpass} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = firwin\_lowpass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map firwin\_lowpass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fiscal\_year\_us}}{fiscal\_year\_us}}\label{fiscal_year_us}

\texttt{fiscal\_year\_us} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fiscal\_year\_us $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fiscal\_year\_us |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fisher\_info\_metric}}{fisher\_info\_metric}}\label{fisher_info_metric}

\texttt{fisher\_info\_metric} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fisher\_info\_metric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fisher\_info\_metric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fisher\_yates\_shuffle}}{fisher\_yates\_shuffle}}\label{fisher_yates_shuffle}

\texttt{fisher\_yates\_shuffle} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fisher\_yates\_shuffle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fisher\_yates\_shuffle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fista\_step}}{fista\_step}}\label{fista_step}

\texttt{fista\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fista\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fista\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{five\_number\_summary}}{five\_number\_summary}}\label{five_number_summary}

\texttt{five\_number\_summary(@data)} (alias \texttt{fivenum}) ---
returns {[}min, Q1, median, Q3, max{]}, the classic five-number summary
used for box plots. Provides a quick view of data distribution.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @data = 1:100}
\NormalTok{my $f = fivenum(@data)}
\NormalTok{p "min=$f{-}\textgreater{}[0] Q1=$f{-}\textgreater{}[1] med=$f{-}\textgreater{}[2] Q3=$f{-}\textgreater{}[3] max=$f{-}\textgreater{}[4]"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_from\_french}}{fixed\_from\_french}}\label{fixed_from_french}

\texttt{fixed\_from\_french} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_from\_french $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_from\_french |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_from\_gregorian}}{fixed\_from\_gregorian}}\label{fixed_from_gregorian}

\texttt{fixed\_from\_gregorian} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_from\_gregorian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_from\_gregorian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_from\_hebrew}}{fixed\_from\_hebrew}}\label{fixed_from_hebrew}

\texttt{fixed\_from\_hebrew} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_from\_hebrew $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_from\_hebrew |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_from\_islamic}}{fixed\_from\_islamic}}\label{fixed_from_islamic}

\texttt{fixed\_from\_islamic} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_from\_islamic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_from\_islamic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_from\_julian}}{fixed\_from\_julian}}\label{fixed_from_julian}

\texttt{fixed\_from\_julian} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_from\_julian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_from\_julian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_from\_persian}}{fixed\_from\_persian}}\label{fixed_from_persian}

\texttt{fixed\_from\_persian} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_from\_persian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_from\_persian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fixed\_quad}}{fixed\_quad}}\label{fixed_quad}

\texttt{fixed\_quad} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fixed\_quad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fixed\_quad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fizzbuzz}}{fizzbuzz}}\label{fizzbuzz}

\texttt{fizzbuzz} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fizzbuzz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fizzbuzz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flat\_band\_potential}}{flat\_band\_potential}}\label{flat_band_potential}

\texttt{flat\_band\_potential} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flat\_band\_potential $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flat\_band\_potential |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flat\_depth}}{flat\_depth}}\label{flat_depth}

\texttt{flat\_depth} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flat\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flat\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flat\_map}}{flat\_map}}\label{flat_map}

\texttt{flat\_map} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flat\_map $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flat\_map |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flat\_map\_fn}}{flat\_map\_fn}}\label{flat_map_fn}

\texttt{flat\_map\_fn} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flat\_map\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flat\_map\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flat\_maps}}{flat\_maps}}\label{flat_maps}

\texttt{flat\_maps\ \{\ BLOCK\ \}\ LIST} --- a lazy streaming flat-map
that evaluates the block for each element and flattens the resulting
lists into a single iterator. Where \texttt{maps} expects the block to
return one value, \texttt{flat\_maps} handles blocks that return zero or
more values per element and concatenates them seamlessly. This is the
streaming equivalent of calling \texttt{map} with a multi-value block.
Use it in \texttt{\textbar{}\textgreater{}} chains when each input
element fans out into multiple outputs and you want lazy evaluation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:3 |\textgreater{} flat\_maps \{ (\_, \_ * 10) \} |\textgreater{} e p}
\NormalTok{\# 1 10 2 20 3 30}
\NormalTok{@nested |\textgreater{} flat\_maps \{ @\_ \} |\textgreater{} e p   \# flatten array{-}of{-}arrays}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flatnonzero}}{flatnonzero}}\label{flatnonzero}

\texttt{flatnonzero} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flatnonzero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flatnonzero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flatten\_deep}}{flatten\_deep}}\label{flatten_deep}

\texttt{flatten\_deep} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flatten\_deep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flatten\_deep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flatten\_once}}{flatten\_once}}\label{flatten_once}

\texttt{flatten\_once} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flatten\_once $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flatten\_once |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flattop\_w}}{flattop\_w}}\label{flattop_w}

\texttt{flattop\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flattop\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flattop\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fldr}}{fldr}}\label{fldr}

\texttt{fldr} --- rust iterator methods builtin. Alias for
\texttt{fold\_right}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fldr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fldr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flesch\_kincaid\_grade}}{flesch\_kincaid\_grade}}\label{flesch_kincaid_grade}

\texttt{flesch\_kincaid\_grade} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flesch\_kincaid\_grade $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flesch\_kincaid\_grade |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flesch\_reading\_ease}}{flesch\_reading\_ease}}\label{flesch_reading_ease}

\texttt{flesch\_reading\_ease} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flesch\_reading\_ease $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flesch\_reading\_ease |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flip\_args}}{flip\_args}}\label{flip_args}

\texttt{flip\_args} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flip\_args $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flip\_args |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{float\_bits}}{float\_bits}}\label{float_bits}

\texttt{float\_bits} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = float\_bits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map float\_bits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floer\_homology\_rank}}{floer\_homology\_rank}}\label{floer_homology_rank}

\texttt{floer\_homology\_rank} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floer\_homology\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floer\_homology\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floor}}{floor}}\label{floor}

\texttt{floor} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floor\_div}}{floor\_div}}\label{floor_div}

\texttt{floor\_div} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floor\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floor\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floor\_div\_op}}{floor\_div\_op}}\label{floor_div_op}

\texttt{floor\_div\_op} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floor\_div\_op $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floor\_div\_op |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floor\_each}}{floor\_each}}\label{floor_each}

\texttt{floor\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floor\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floor\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floor\_mod}}{floor\_mod}}\label{floor_mod}

\texttt{floor\_mod} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floor\_mod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floor\_mod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flow\_shop\_johnson\_step}}{flow\_shop\_johnson\_step}}\label{flow_shop_johnson_step}

\texttt{flow\_shop\_johnson\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flow\_shop\_johnson\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flow\_shop\_johnson\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{floyd\_warshall\_step}}{floyd\_warshall\_step}}\label{floyd_warshall_step}

\texttt{floyd\_warshall\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = floyd\_warshall\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map floyd\_warshall\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fltd}}{fltd}}\label{fltd}

\texttt{fltd} --- javascript array/object methods builtin. Alias for
\texttt{flat\_depth}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fltd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fltd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flti}}{flti}}\label{flti}

\texttt{flti} --- go/general functional utilities builtin. Alias for
\texttt{filter\_indexed}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flti $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flti |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fltm}}{fltm}}\label{fltm}

\texttt{fltm} --- rust iterator methods builtin. Alias for
\texttt{filter\_map}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fltm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fltm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{flux\_richardson\_full}}{flux\_richardson\_full}}\label{flux_richardson_full}

\texttt{flux\_richardson\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = flux\_richardson\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map flux\_richardson\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fma}}{fma}}\label{fma}

\texttt{fma} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fmadd}}{fmadd}}\label{fmadd}

\texttt{fmadd} --- extended stdlib builtin. Alias for
\texttt{fused\_mul\_add}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fmadd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fmadd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fmf}}{fmf}}\label{fmf}

\texttt{fmf} --- python/ruby stdlib builtin. Alias for
\texttt{flat\_map\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fmf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fmf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fmin\_cobyla}}{fmin\_cobyla}}\label{fmin_cobyla}

\texttt{fmin\_cobyla} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fmin\_cobyla $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fmin\_cobyla |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fmin\_powell}}{fmin\_powell}}\label{fmin_powell}

\texttt{fmin\_powell} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fmin\_powell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fmin\_powell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fmod}}{fmod}}\label{fmod}

\texttt{fmod} --- extended stdlib builtin. Alias for
\texttt{floor\_mod}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fmod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fmod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fndalli}}{fndalli}}\label{fndalli}

\texttt{fndalli} --- extended stdlib builtin. Alias for
\texttt{find\_all\_indices}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fndalli $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fndalli |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fndidxs}}{fndidxs}}\label{fndidxs}

\texttt{fndidxs} --- additional missing stdlib functions builtin. Alias
for \texttt{find\_indices}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fndidxs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fndidxs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fndl}}{fndl}}\label{fndl}

\texttt{fndl} --- javascript array/object methods builtin. Alias for
\texttt{find\_last}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fndl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fndl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fndli}}{fndli}}\label{fndli}

\texttt{fndli} --- javascript array/object methods builtin. Alias for
\texttt{find\_last\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fndli $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fndli |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fndm}}{fndm}}\label{fndm}

\texttt{fndm} --- rust iterator methods builtin. Alias for
\texttt{find\_map}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fndm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fndm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fne}}{fne}}\label{fne}

\texttt{fne} --- algebraic match builtin. Alias for \texttt{fnext}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fne $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fne |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnext}}{fnext}}\label{fnext}

\texttt{fnext} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fnext $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fnext |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnv0\_32}}{fnv0\_32}}\label{fnv0_32}

\texttt{fnv0\_32} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fnv0\_32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fnv0\_32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnv1a}}{fnv1a}}\label{fnv1a}

\texttt{fnv1a} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fnv1a $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fnv1a |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnv1a\_32}}{fnv1a\_32}}\label{fnv1a_32}

\texttt{fnv1a\_32} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fnv1a\_32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fnv1a\_32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnv1a\_64}}{fnv1a\_64}}\label{fnv1a_64}

\texttt{fnv1a\_64} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fnv1a\_64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fnv1a\_64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fnv1a\_hash}}{fnv1a\_hash}}\label{fnv1a_hash}

\texttt{fnv1a\_hash} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fnv1a\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fnv1a\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fold\_axis}}{fold\_axis}}\label{fold_axis}

\texttt{fold\_axis} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fold\_axis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fold\_axis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fold\_left}}{fold\_left}}\label{fold_left}

\texttt{fold\_left} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fold\_left $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fold\_left |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fold\_right}}{fold\_right}}\label{fold_right}

\texttt{fold\_right} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fold\_right $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fold\_right |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{folk\_theorem\_value}}{folk\_theorem\_value}}\label{folk_theorem_value}

\texttt{folk\_theorem\_value} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = folk\_theorem\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map folk\_theorem\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{force\_mass\_acc}}{force\_mass\_acc}}\label{force_mass_acc}

\texttt{force\_mass\_acc} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = force\_mass\_acc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map force\_mass\_acc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{force\_of\_mortality}}{force\_of\_mortality}}\label{force_of_mortality}

\texttt{force\_of\_mortality} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = force\_of\_mortality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map force\_of\_mortality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ford\_fulkerson\_step}}{ford\_fulkerson\_step}}\label{ford_fulkerson_step}

\texttt{ford\_fulkerson\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ford\_fulkerson\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ford\_fulkerson\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{formal\_charge}}{formal\_charge}}\label{formal_charge}

\texttt{formal\_charge} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = formal\_charge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map formal\_charge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{format\_bytes}}{format\_bytes}}\label{format_bytes}

\texttt{format\_bytes} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = format\_bytes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map format\_bytes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{format\_duration}}{format\_duration}}\label{format_duration}

\texttt{format\_duration} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = format\_duration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map format\_duration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{format\_number}}{format\_number}}\label{format_number}

\texttt{format\_number} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = format\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map format\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{format\_percent}}{format\_percent}}\label{format_percent}

\texttt{format\_percent} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = format\_percent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map format\_percent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{format\_table\_simple}}{format\_table\_simple}}\label{format_table_simple}

\texttt{format\_table\_simple} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = format\_table\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map format\_table\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{forward\_backward\_pos}}{forward\_backward\_pos}}\label{forward_backward_pos}

\texttt{forward\_backward\_pos} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = forward\_backward\_pos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map forward\_backward\_pos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{forward\_kinematics\_dh}}{forward\_kinematics\_dh}}\label{forward_kinematics_dh}

\texttt{forward\_kinematics\_dh} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = forward\_kinematics\_dh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map forward\_kinematics\_dh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{forward\_rate}}{forward\_rate}}\label{forward_rate}

\texttt{forward\_rate} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = forward\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map forward\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fourier\_number\_step}}{fourier\_number\_step}}\label{fourier_number_step}

\texttt{fourier\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fourier\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fourier\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fp\_depression}}{fp\_depression}}\label{fp_depression}

\texttt{fp\_depression} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fp\_depression $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fp\_depression |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fr}}{fr}}\label{fr}

\texttt{fr} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frac\_part}}{frac\_part}}\label{frac_part}

\texttt{frac\_part} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = frac\_part $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map frac\_part |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fracp}}{fracp}}\label{fracp}

\texttt{fracp} --- extended stdlib builtin. Alias for
\texttt{frac\_part}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fracp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fracp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fractional\_chromatic\_lower}}{fractional\_chromatic\_lower}}\label{fractional_chromatic_lower}

\texttt{fractional\_chromatic\_lower} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fractional\_chromatic\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fractional\_chromatic\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frank\_wolfe\_step}}{frank\_wolfe\_step}}\label{frank_wolfe_step}

\texttt{frank\_wolfe\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = frank\_wolfe\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map frank\_wolfe\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fredkin\_gate}}{fredkin\_gate}}\label{fredkin_gate}

\texttt{fredkin\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fredkin\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fredkin\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{free\_energy\_principle}}{free\_energy\_principle}}\label{free_energy_principle}

\texttt{free\_energy\_principle} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = free\_energy\_principle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map free\_energy\_principle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{free\_group\_rank\_lower}}{free\_group\_rank\_lower}}\label{free_group_rank_lower}

\texttt{free\_group\_rank\_lower} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = free\_group\_rank\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map free\_group\_rank\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{free\_particle\_energy}}{free\_particle\_energy}}\label{free_particle_energy}

\texttt{free\_particle\_energy} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = free\_particle\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map free\_particle\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{freefall\_time}}{freefall\_time}}\label{freefall_time}

\texttt{freefall\_time} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = freefall\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map freefall\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{freefall\_velocity\_schwarzschild}}{freefall\_velocity\_schwarzschild}}\label{freefall_velocity_schwarzschild}

\texttt{freefall\_velocity\_schwarzschild} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = freefall\_velocity\_schwarzschild $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map freefall\_velocity\_schwarzschild |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{french\_revolutionary\_leap}}{french\_revolutionary\_leap}}\label{french_revolutionary_leap}

\texttt{french\_revolutionary\_leap} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = french\_revolutionary\_leap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map french\_revolutionary\_leap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{freq\_wavelength}}{freq\_wavelength}}\label{freq_wavelength}

\texttt{freq\_wavelength} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = freq\_wavelength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map freq\_wavelength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{freqs\_eval}}{freqs\_eval}}\label{freqs_eval}

\texttt{freqs\_eval} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = freqs\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map freqs\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{freqz\_eval}}{freqz\_eval}}\label{freqz_eval}

\texttt{freqz\_eval} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = freqz\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map freqz\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fresnel\_reflection\_normal}}{fresnel\_reflection\_normal}}\label{fresnel_reflection_normal}

\texttt{fresnel\_reflection\_normal} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fresnel\_reflection\_normal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fresnel\_reflection\_normal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fresnel\_rp}}{fresnel\_rp}}\label{fresnel_rp}

\texttt{fresnel\_rp} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fresnel\_rp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fresnel\_rp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fresnel\_rs}}{fresnel\_rs}}\label{fresnel_rs}

\texttt{fresnel\_rs} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fresnel\_rs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fresnel\_rs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{friction\_factor\_laminar}}{friction\_factor\_laminar}}\label{friction_factor_laminar}

\texttt{friction\_factor\_laminar} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = friction\_factor\_laminar $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map friction\_factor\_laminar |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{friedmann\_density\_total}}{friedmann\_density\_total}}\label{friedmann_density_total}

\texttt{friedmann\_density\_total} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = friedmann\_density\_total $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map friedmann\_density\_total |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_base}}{from\_base}}\label{from_base}

\texttt{from\_base} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_bin}}{from\_bin}}\label{from_bin}

\texttt{from\_bin} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_bin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_bin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_code\_point}}{from\_code\_point}}\label{from_code_point}

\texttt{from\_code\_point} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_code\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_code\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_csv\_line}}{from\_csv\_line}}\label{from_csv_line}

\texttt{from\_csv\_line} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_csv\_line $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_csv\_line |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_digits}}{from\_digits}}\label{from_digits}

\texttt{from\_digits} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_digits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_digits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_hex}}{from\_hex}}\label{from_hex}

\texttt{from\_hex} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_hex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_hex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_oct}}{from\_oct}}\label{from_oct}

\texttt{from\_oct} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_oct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_oct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{from\_pairs}}{from\_pairs}}\label{from_pairs}

\texttt{from\_pairs} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = from\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map from\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{froude\_number}}{froude\_number}}\label{froude_number}

\texttt{froude\_number} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = froude\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map froude\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{froude\_number\_step}}{froude\_number\_step}}\label{froude_number_step}

\texttt{froude\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = froude\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map froude\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frustum\_volume}}{frustum\_volume}}\label{frustum_volume}

\texttt{frustum\_volume(\$r1,\ \$r2,\ \$h)} --- computes the volume of a
conical frustum (truncated cone) with base radii r1 and r2 and height h.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p frustum\_volume(5, 3, 10)   \# \textasciitilde{}513}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{frustvol}}{frustvol}}\label{frustvol}

\texttt{frustvol} --- geometry (extended) builtin. Alias for
\texttt{frustum\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = frustvol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map frustvol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fsize}}{fsize}}\label{fsize}

\texttt{fsize} --- file stat / path builtin. Alias for
\texttt{file\_size}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fsize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fsize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fst}}{fst}}\label{fst}

\texttt{fst} --- functional / iterator builtin. Alias for
\texttt{first}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ft}}{ft}}\label{ft}

\texttt{ft} --- data / network builtin. Alias for \texttt{fetch}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ft $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ft |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fta}}{fta}}\label{fta}

\texttt{fta} --- data / network builtin. Alias for
\texttt{fetch\_async}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ftaj}}{ftaj}}\label{ftaj}

\texttt{ftaj} --- data / network builtin. Alias for
\texttt{fetch\_async\_json}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ftaj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ftaj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ftj}}{ftj}}\label{ftj}

\texttt{ftj} --- data / network builtin. Alias for \texttt{fetch\_json}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ftj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ftj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fuel\_cell\_polarization}}{fuel\_cell\_polarization}}\label{fuel_cell_polarization}

\texttt{fuel\_cell\_polarization} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fuel\_cell\_polarization $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fuel\_cell\_polarization |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fundamental\_group\_zn}}{fundamental\_group\_zn}}\label{fundamental_group_zn}

\texttt{fundamental\_group\_zn} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fundamental\_group\_zn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fundamental\_group\_zn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fused\_mul\_add}}{fused\_mul\_add}}\label{fused_mul_add}

\texttt{fused\_mul\_add} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fused\_mul\_add $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fused\_mul\_add |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fusion\_rule\_su2\_step}}{fusion\_rule\_su2\_step}}\label{fusion_rule_su2_step}

\texttt{fusion\_rule\_su2\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fusion\_rule\_su2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fusion\_rule\_su2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{future\_value}}{future\_value}}\label{future_value}

\texttt{future\_value} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = future\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map future\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fv}}{fv}}\label{fv}

\texttt{fv} --- python/ruby stdlib builtin. Alias for
\texttt{fetch\_val}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{fx\_forward}}{fx\_forward}}\label{fx_forward}

\texttt{fx\_forward} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = fx\_forward $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map fx\_forward |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{g2\_zero}}{g2\_zero}}\label{g2_zero}

\texttt{g2\_zero} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = g2\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map g2\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{g\_to\_oz}}{g\_to\_oz}}\label{g_to_oz}

\texttt{g\_to\_oz} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = g\_to\_oz $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gabor\_filter}}{gabor\_filter}}\label{gabor_filter}

\texttt{gabor\_filter} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gabor\_filter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gabor\_filter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gabor\_kernel}}{gabor\_kernel}}\label{gabor_kernel}

\texttt{gabor\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gabor\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gabor\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gae\_advantage\_step}}{gae\_advantage\_step}}\label{gae_advantage_step}

\texttt{gae\_advantage\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gae\_advantage\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gae\_advantage\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gain\_ratio}}{gain\_ratio}}\label{gain_ratio}

\texttt{gain\_ratio} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gain\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gain\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gale\_optimal}}{gale\_optimal}}\label{gale_optimal}

\texttt{gale\_optimal} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gale\_optimal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gale\_optimal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gale\_shapley\_step}}{gale\_shapley\_step}}\label{gale_shapley_step}

\texttt{gale\_shapley\_step} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gale\_shapley\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gale\_shapley\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gallons\_to\_liters}}{gallons\_to\_liters}}\label{gallons_to_liters}

\texttt{gallons\_to\_liters} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gallons\_to\_liters $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{game\_of\_life\_step}}{game\_of\_life\_step}}\label{game_of_life_step}

\texttt{game\_of\_life\_step} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = game\_of\_life\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map game\_of\_life\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{game\_two\_player\_value}}{game\_two\_player\_value}}\label{game_two_player_value}

\texttt{game\_two\_player\_value} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = game\_two\_player\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map game\_two\_player\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gamma\_approx}}{gamma\_approx}}\label{gamma_approx}

\texttt{gamma\_approx(\$z)} --- Gamma function Γ(z) using Lanczos
approximation. Extends factorial: Γ(n) = (n-1)!

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gamma(5)    \# 24 (same as 4!)}
\NormalTok{p gamma(0.5)  \# \textasciitilde{}1.772 (√π)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gamma\_pdf}}{gamma\_pdf}}\label{gamma_pdf}

\texttt{gamma\_pdf} (alias \texttt{gammapdf}) evaluates the Gamma
distribution PDF at x with shape k and scale theta.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gammapdf(2.0, 2, 1)  \# Gamma(2,1) at x=2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gamow\_factor}}{gamow\_factor}}\label{gamow_factor}

\texttt{gamow\_factor} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gamow\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gamow\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{garch\_fit}}{garch\_fit}}\label{garch_fit}

\texttt{garch\_fit} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = garch\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map garch\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{garch\_step}}{garch\_step}}\label{garch_step}

\texttt{garch\_step} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = garch\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map garch\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{garman\_kohlhagen\_call}}{garman\_kohlhagen\_call}}\label{garman_kohlhagen_call}

\texttt{garman\_kohlhagen\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = garman\_kohlhagen\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map garman\_kohlhagen\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gas\_constant}}{gas\_constant}}\label{gas_constant}

\texttt{gas\_constant} (alias \texttt{rgas}) --- R ≈ 8.314 J/(mol⋅K).
Universal gas constant.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p rgas   \# 8.314462618}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gas\_constant\_r}}{gas\_constant\_r}}\label{gas_constant_r}

\texttt{gas\_constant\_r} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gas\_constant\_r $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gas\_constant\_r |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gas\_constant\_value}}{gas\_constant\_value}}\label{gas_constant_value}

\texttt{gas\_constant\_value} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gas\_constant\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gas\_constant\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gasp}}{gasp}}\label{gasp}

\texttt{ideal\_gas\_pressure(\$n,\ \$V,\ \$T)} (alias \texttt{gasp}) ---
pressure P = nRT/V. n moles, V volume (m³), T temperature (K).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gasp(1, 0.0224, 273.15)   \# \textasciitilde{}101325 Pa (1 mol at STP)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gasv}}{gasv}}\label{gasv}

\texttt{gasv} --- physics formulas builtin. Alias for
\texttt{ideal\_gas\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gasv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gasv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gate\_decompose}}{gate\_decompose}}\label{gate_decompose}

\texttt{gate\_decompose} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gate\_decompose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gate\_decompose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauss\_bonnet\_term\_2d}}{gauss\_bonnet\_term\_2d}}\label{gauss_bonnet_term_2d}

\texttt{gauss\_bonnet\_term\_2d} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gauss\_bonnet\_term\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gauss\_bonnet\_term\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauss\_bonnet\_total}}{gauss\_bonnet\_total}}\label{gauss_bonnet_total}

\texttt{gauss\_bonnet\_total} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gauss\_bonnet\_total $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gauss\_bonnet\_total |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauss\_codazzi\_step}}{gauss\_codazzi\_step}}\label{gauss_codazzi_step}

\texttt{gauss\_codazzi\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gauss\_codazzi\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gauss\_codazzi\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauss\_irk\_2\_stage}}{gauss\_irk\_2\_stage}}\label{gauss_irk_2_stage}

\texttt{gauss\_irk\_2\_stage} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gauss\_irk\_2\_stage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gauss\_irk\_2\_stage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauss\_kronrod\_15}}{gauss\_kronrod\_15}}\label{gauss_kronrod_15}

\texttt{gauss\_kronrod\_15} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gauss\_kronrod\_15 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gauss\_kronrod\_15 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gauss\_legendre\_5}}{gauss\_legendre\_5}}\label{gauss_legendre_5}

\texttt{gauss\_legendre\_5} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gauss\_legendre\_5 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gauss\_legendre\_5 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gaussian\_curvature\_step}}{gaussian\_curvature\_step}}\label{gaussian_curvature_step}

\texttt{gaussian\_curvature\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gaussian\_curvature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gaussian\_curvature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gaussian\_filter\_window}}{gaussian\_filter\_window}}\label{gaussian_filter_window}

\texttt{gaussian\_filter\_window} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gaussian\_filter\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gaussian\_filter\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gaussian\_window}}{gaussian\_window}}\label{gaussian_window}

\texttt{gaussian\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gaussian\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gaussian\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gb\_to\_bytes}}{gb\_to\_bytes}}\label{gb_to_bytes}

\texttt{gb\_to\_bytes} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gb\_to\_bytes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gbf}}{gbf}}\label{gbf}

\texttt{gbf} --- go/general functional utilities builtin. Alias for
\texttt{group\_by\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gbf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gbf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gbi}}{gbi}}\label{gbi}

\texttt{gbi} --- python/ruby stdlib builtin. Alias for
\texttt{groupby\_iter}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gbi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gbi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gcby}}{gcby}}\label{gcby}

\texttt{gcby} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{group\_consecutive\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gcby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gcby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gcd}}{gcd}}\label{gcd}

\texttt{gcd} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gcd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gcd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gconst}}{gconst}}\label{gconst}

\texttt{gconst} --- constants builtin. Alias for
\texttt{gravitational\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gconst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gconst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gelu}}{gelu}}\label{gelu}

\texttt{gelu} applies the Gaussian Error Linear Unit, used in BERT/GPT
transformers.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gelu(1)    \# 0.8412}
\NormalTok{p gelu({-}1)   \# {-}0.1588}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{generalized\_advantage}}{generalized\_advantage}}\label{generalized_advantage}

\texttt{generalized\_advantage} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = generalized\_advantage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map generalized\_advantage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{generation\_time}}{generation\_time}}\label{generation_time}

\texttt{generation\_time} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = generation\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map generation\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{generation\_time\_demo}}{generation\_time\_demo}}\label{generation_time_demo}

\texttt{generation\_time\_demo} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = generation\_time\_demo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map generation\_time\_demo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{generation\_time\_step}}{generation\_time\_step}}\label{generation_time_step}

\texttt{generation\_time\_step} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = generation\_time\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map generation\_time\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{genetic\_crossover\_one\_point}}{genetic\_crossover\_one\_point}}\label{genetic_crossover_one_point}

\texttt{genetic\_crossover\_one\_point} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = genetic\_crossover\_one\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map genetic\_crossover\_one\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{genus\_curve\_arith}}{genus\_curve\_arith}}\label{genus_curve_arith}

\texttt{genus\_curve\_arith} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = genus\_curve\_arith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map genus\_curve\_arith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{genus\_curve\_geo}}{genus\_curve\_geo}}\label{genus_curve_geo}

\texttt{genus\_curve\_geo} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = genus\_curve\_geo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map genus\_curve\_geo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{genus\_from\_euler}}{genus\_from\_euler}}\label{genus_from_euler}

\texttt{genus\_from\_euler} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = genus\_from\_euler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map genus\_from\_euler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{genus\_surface}}{genus\_surface}}\label{genus_surface}

\texttt{genus\_surface} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = genus\_surface $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map genus\_surface |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geoadd}}{geoadd}}\label{geoadd}

\texttt{geoadd} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geoadd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geoadd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geodesic\_curvature\_step}}{geodesic\_curvature\_step}}\label{geodesic_curvature_step}

\texttt{geodesic\_curvature\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geodesic\_curvature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geodesic\_curvature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geodesic\_equation\_step\_zero}}{geodesic\_equation\_step\_zero}}\label{geodesic_equation_step_zero}

\texttt{geodesic\_equation\_step\_zero} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geodesic\_equation\_step\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geodesic\_equation\_step\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geodist}}{geodist}}\label{geodist}

\texttt{geodist} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geodist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geodist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geohash}}{geohash}}\label{geohash}

\texttt{geohash} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geohash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geohash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geohash\_bbox}}{geohash\_bbox}}\label{geohash_bbox}

\texttt{geohash\_bbox} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geohash\_bbox $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geohash\_bbox |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geohash\_decode}}{geohash\_decode}}\label{geohash_decode}

\texttt{geohash\_decode} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geohash\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geohash\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geohash\_encode}}{geohash\_encode}}\label{geohash_encode}

\texttt{geohash\_encode} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geohash\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geohash\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geohash\_neighbor}}{geohash\_neighbor}}\label{geohash_neighbor}

\texttt{geohash\_neighbor} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geohash\_neighbor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geohash\_neighbor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geohash\_neighbors}}{geohash\_neighbors}}\label{geohash_neighbors}

\texttt{geohash\_neighbors} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geohash\_neighbors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geohash\_neighbors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geomagnetic\_kp\_index}}{geomagnetic\_kp\_index}}\label{geomagnetic_kp_index}

\texttt{geomagnetic\_kp\_index} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geomagnetic\_kp\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geomagnetic\_kp\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geometric\_height\_full}}{geometric\_height\_full}}\label{geometric_height_full}

\texttt{geometric\_height\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geometric\_height\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geometric\_height\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geometric\_intersection\_number}}{geometric\_intersection\_number}}\label{geometric_intersection_number}

\texttt{geometric\_intersection\_number} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geometric\_intersection\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geometric\_intersection\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geometric\_mean}}{geometric\_mean}}\label{geometric_mean}

\texttt{geometric\_mean} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geometric\_mean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geometric\_mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geometric\_mean\_arr}}{geometric\_mean\_arr}}\label{geometric_mean_arr}

\texttt{geometric\_mean\_arr} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geometric\_mean\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geometric\_mean\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geometric\_sequence}}{geometric\_sequence}}\label{geometric_sequence}

\texttt{geometric\_sequence} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geometric\_sequence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geometric\_sequence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geometric\_series}}{geometric\_series}}\label{geometric_series}

\texttt{geometric\_series(\$a1,\ \$r,\ \$n)} (alias \texttt{geomser})
--- sum of n terms of geometric sequence. Formula: a1×(1-rⁿ)/(1-r). If
r=1, returns a1×n.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p geomser(1, 2, 10)      \# 1023 (1+2+4+...+512)}
\NormalTok{p geomser(1, 0.5, 10)    \# \textasciitilde{}1.998 (converging to 2)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geopotential\_height\_full}}{geopotential\_height\_full}}\label{geopotential_height_full}

\texttt{geopotential\_height\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geopotential\_height\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geopotential\_height\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{geostrophic\_wind\_step}}{geostrophic\_wind\_step}}\label{geostrophic_wind_step}

\texttt{geostrophic\_wind\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = geostrophic\_wind\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map geostrophic\_wind\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{get\_in}}{get\_in}}\label{get_in}

\texttt{get\_in} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = get\_in $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map get\_in |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gethostent}}{gethostent}}\label{gethostent}

\texttt{gethostent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gethostent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gethostent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getnetbyname}}{getnetbyname}}\label{getnetbyname}

\texttt{getnetbyname} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = getnetbyname $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map getnetbyname |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getnetent}}{getnetent}}\label{getnetent}

\texttt{getnetent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = getnetent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map getnetent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getprotoent}}{getprotoent}}\label{getprotoent}

\texttt{getprotoent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = getprotoent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map getprotoent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getrange}}{getrange}}\label{getrange}

\texttt{getrange} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = getrange $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map getrange |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getservent}}{getservent}}\label{getservent}

\texttt{getservent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = getservent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map getservent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{getset}}{getset}}\label{getset}

\texttt{getset} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = getset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map getset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gf256\_multiply}}{gf256\_multiply}}\label{gf256_multiply}

\texttt{gf256\_multiply} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gf256\_multiply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gf256\_multiply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gforce}}{gforce}}\label{gforce}

\texttt{gravitational\_force(\$m1,\ \$m2,\ \$r)} (alias \texttt{gforce})
--- Newton\textquotesingle s law of gravitation: F = Gm₁m₂/r².

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gforce(5.972e24, 1000, 6.371e6)   \# \textasciitilde{}9820 N (1 ton at Earth surface)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_aabb\_intersect\_check}}{gfx\_aabb\_intersect\_check}}\label{gfx_aabb_intersect_check}

\texttt{gfx\_aabb\_intersect\_check} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_aabb\_intersect\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_aabb\_intersect\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_axis\_angle\_to\_quat}}{gfx\_axis\_angle\_to\_quat}}\label{gfx_axis_angle_to_quat}

\texttt{gfx\_axis\_angle\_to\_quat} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_axis\_angle\_to\_quat $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_barycentric\_alpha}}{gfx\_barycentric\_alpha}}\label{gfx_barycentric_alpha}

\texttt{gfx\_barycentric\_alpha} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_barycentric\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_barycentric\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_barycentric\_beta}}{gfx\_barycentric\_beta}}\label{gfx_barycentric_beta}

\texttt{gfx\_barycentric\_beta} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_barycentric\_beta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_barycentric\_beta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_barycentric\_gamma}}{gfx\_barycentric\_gamma}}\label{gfx_barycentric_gamma}

\texttt{gfx\_barycentric\_gamma} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_barycentric\_gamma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_barycentric\_gamma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_blinn\_specular\_step}}{gfx\_blinn\_specular\_step}}\label{gfx_blinn_specular_step}

\texttt{gfx\_blinn\_specular\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_blinn\_specular\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_blinn\_specular\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_blue\_noise\_value}}{gfx\_blue\_noise\_value}}\label{gfx_blue_noise_value}

\texttt{gfx\_blue\_noise\_value} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_blue\_noise\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_blue\_noise\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_bresenham\_step\_x}}{gfx\_bresenham\_step\_x}}\label{gfx_bresenham_step_x}

\texttt{gfx\_bresenham\_step\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_bresenham\_step\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_bresenham\_step\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_bresenham\_step\_y}}{gfx\_bresenham\_step\_y}}\label{gfx_bresenham_step_y}

\texttt{gfx\_bresenham\_step\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_bresenham\_step\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_bresenham\_step\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_clip\_polygon\_step}}{gfx\_clip\_polygon\_step}}\label{gfx_clip_polygon_step}

\texttt{gfx\_clip\_polygon\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_clip\_polygon\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_clip\_polygon\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_cohen\_sutherland\_code}}{gfx\_cohen\_sutherland\_code}}\label{gfx_cohen_sutherland_code}

\texttt{gfx\_cohen\_sutherland\_code} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_cohen\_sutherland\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_cohen\_sutherland\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_cook\_torrance\_d\_ggx}}{gfx\_cook\_torrance\_d\_ggx}}\label{gfx_cook_torrance_d_ggx}

\texttt{gfx\_cook\_torrance\_d\_ggx} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_cook\_torrance\_d\_ggx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_cook\_torrance\_d\_ggx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_cook\_torrance\_f\_schlick}}{gfx\_cook\_torrance\_f\_schlick}}\label{gfx_cook_torrance_f_schlick}

\texttt{gfx\_cook\_torrance\_f\_schlick} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_cook\_torrance\_f\_schlick $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_cook\_torrance\_f\_schlick |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_cook\_torrance\_g\_smith}}{gfx\_cook\_torrance\_g\_smith}}\label{gfx_cook_torrance_g_smith}

\texttt{gfx\_cook\_torrance\_g\_smith} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_cook\_torrance\_g\_smith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_cook\_torrance\_g\_smith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_cube\_map\_face\_index}}{gfx\_cube\_map\_face\_index}}\label{gfx_cube_map_face_index}

\texttt{gfx\_cube\_map\_face\_index} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_cube\_map\_face\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_cube\_map\_face\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_curl\_noise\_step}}{gfx\_curl\_noise\_step}}\label{gfx_curl_noise_step}

\texttt{gfx\_curl\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_curl\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_curl\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_disney\_principled\_d}}{gfx\_disney\_principled\_d}}\label{gfx_disney_principled_d}

\texttt{gfx\_disney\_principled\_d} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_disney\_principled\_d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_disney\_principled\_d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_dither\_bayer\_4x4}}{gfx\_dither\_bayer\_4x4}}\label{gfx_dither_bayer_4x4}

\texttt{gfx\_dither\_bayer\_4x4} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_dither\_bayer\_4x4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_dither\_bayer\_4x4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_dither\_floyd\_steinberg}}{gfx\_dither\_floyd\_steinberg}}\label{gfx_dither_floyd_steinberg}

\texttt{gfx\_dither\_floyd\_steinberg} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_dither\_floyd\_steinberg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_dither\_floyd\_steinberg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_environment\_map\_uv\_u}}{gfx\_environment\_map\_uv\_u}}\label{gfx_environment_map_uv_u}

\texttt{gfx\_environment\_map\_uv\_u} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_environment\_map\_uv\_u $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_environment\_map\_uv\_u |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_environment\_map\_uv\_v}}{gfx\_environment\_map\_uv\_v}}\label{gfx_environment_map_uv_v}

\texttt{gfx\_environment\_map\_uv\_v} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_environment\_map\_uv\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_environment\_map\_uv\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_euler\_to\_quat\_w}}{gfx\_euler\_to\_quat\_w}}\label{gfx_euler_to_quat_w}

\texttt{gfx\_euler\_to\_quat\_w} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_euler\_to\_quat\_w $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_euler\_to\_quat\_x}}{gfx\_euler\_to\_quat\_x}}\label{gfx_euler_to_quat_x}

\texttt{gfx\_euler\_to\_quat\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_euler\_to\_quat\_x $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_euler\_to\_quat\_y}}{gfx\_euler\_to\_quat\_y}}\label{gfx_euler_to_quat_y}

\texttt{gfx\_euler\_to\_quat\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_euler\_to\_quat\_y $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_euler\_to\_quat\_z}}{gfx\_euler\_to\_quat\_z}}\label{gfx_euler_to_quat_z}

\texttt{gfx\_euler\_to\_quat\_z} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_euler\_to\_quat\_z $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_fbm\_noise\_step}}{gfx\_fbm\_noise\_step}}\label{gfx_fbm_noise_step}

\texttt{gfx\_fbm\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_fbm\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_fbm\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_fresnel\_conductor\_step}}{gfx\_fresnel\_conductor\_step}}\label{gfx_fresnel_conductor_step}

\texttt{gfx\_fresnel\_conductor\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_fresnel\_conductor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_fresnel\_conductor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_fresnel\_dielectric\_step}}{gfx\_fresnel\_dielectric\_step}}\label{gfx_fresnel_dielectric_step}

\texttt{gfx\_fresnel\_dielectric\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_fresnel\_dielectric\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_fresnel\_dielectric\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_gamma\_correct\_step}}{gfx\_gamma\_correct\_step}}\label{gfx_gamma_correct_step}

\texttt{gfx\_gamma\_correct\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_gamma\_correct\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_gamma\_correct\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_geometric\_attenuation\_smith}}{gfx\_geometric\_attenuation\_smith}}\label{gfx_geometric_attenuation_smith}

\texttt{gfx\_geometric\_attenuation\_smith} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_geometric\_attenuation\_smith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_geometric\_attenuation\_smith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_gradient\_noise\_step}}{gfx\_gradient\_noise\_step}}\label{gfx_gradient_noise_step}

\texttt{gfx\_gradient\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_gradient\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_gradient\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_halton\_step}}{gfx\_halton\_step}}\label{gfx_halton_step}

\texttt{gfx\_halton\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_halton\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_halton\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_homogeneous\_divide}}{gfx\_homogeneous\_divide}}\label{gfx_homogeneous_divide}

\texttt{gfx\_homogeneous\_divide} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_homogeneous\_divide $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_homogeneous\_divide |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_index\_of\_refraction}}{gfx\_index\_of\_refraction}}\label{gfx_index_of_refraction}

\texttt{gfx\_index\_of\_refraction} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_index\_of\_refraction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_index\_of\_refraction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_irradiance\_sh\_eval}}{gfx\_irradiance\_sh\_eval}}\label{gfx_irradiance_sh_eval}

\texttt{gfx\_irradiance\_sh\_eval} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_irradiance\_sh\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_irradiance\_sh\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_lambert\_term}}{gfx\_lambert\_term}}\label{gfx_lambert_term}

\texttt{gfx\_lambert\_term} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_lambert\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_lambert\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_liang\_barsky\_t}}{gfx\_liang\_barsky\_t}}\label{gfx_liang_barsky_t}

\texttt{gfx\_liang\_barsky\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_liang\_barsky\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_liang\_barsky\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_linear\_to\_srgb}}{gfx\_linear\_to\_srgb}}\label{gfx_linear_to_srgb}

\texttt{gfx\_linear\_to\_srgb} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_linear\_to\_srgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_lookat\_forward}}{gfx\_lookat\_forward}}\label{gfx_lookat_forward}

\texttt{gfx\_lookat\_forward} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_lookat\_forward $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_lookat\_forward |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_lookat\_right}}{gfx\_lookat\_right}}\label{gfx_lookat_right}

\texttt{gfx\_lookat\_right} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_lookat\_right $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_lookat\_right |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_lookat\_up}}{gfx\_lookat\_up}}\label{gfx_lookat_up}

\texttt{gfx\_lookat\_up} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_lookat\_up $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_lookat\_up |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_low\_discrepancy\_step}}{gfx\_low\_discrepancy\_step}}\label{gfx_low_discrepancy_step}

\texttt{gfx\_low\_discrepancy\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_low\_discrepancy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_low\_discrepancy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_microfacet\_brdf\_step}}{gfx\_microfacet\_brdf\_step}}\label{gfx_microfacet_brdf_step}

\texttt{gfx\_microfacet\_brdf\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_microfacet\_brdf\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_microfacet\_brdf\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ndc\_to\_screen\_x}}{gfx\_ndc\_to\_screen\_x}}\label{gfx_ndc_to_screen_x}

\texttt{gfx\_ndc\_to\_screen\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ndc\_to\_screen\_x $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ndc\_to\_screen\_y}}{gfx\_ndc\_to\_screen\_y}}\label{gfx_ndc_to_screen_y}

\texttt{gfx\_ndc\_to\_screen\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ndc\_to\_screen\_y $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_normal\_distribution\_ggx}}{gfx\_normal\_distribution\_ggx}}\label{gfx_normal_distribution_ggx}

\texttt{gfx\_normal\_distribution\_ggx} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_normal\_distribution\_ggx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_normal\_distribution\_ggx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_obb\_overlap\_step}}{gfx\_obb\_overlap\_step}}\label{gfx_obb_overlap_step}

\texttt{gfx\_obb\_overlap\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_obb\_overlap\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_obb\_overlap\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_octahedral\_encode\_x}}{gfx\_octahedral\_encode\_x}}\label{gfx_octahedral_encode_x}

\texttt{gfx\_octahedral\_encode\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_octahedral\_encode\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_octahedral\_encode\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_octahedral\_encode\_y}}{gfx\_octahedral\_encode\_y}}\label{gfx_octahedral_encode_y}

\texttt{gfx\_octahedral\_encode\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_octahedral\_encode\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_octahedral\_encode\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_oklab\_a\_step}}{gfx\_oklab\_a\_step}}\label{gfx_oklab_a_step}

\texttt{gfx\_oklab\_a\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_oklab\_a\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_oklab\_a\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_oklab\_b\_step}}{gfx\_oklab\_b\_step}}\label{gfx_oklab_b_step}

\texttt{gfx\_oklab\_b\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_oklab\_b\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_oklab\_b\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_oklab\_l\_step}}{gfx\_oklab\_l\_step}}\label{gfx_oklab_l_step}

\texttt{gfx\_oklab\_l\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_oklab\_l\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_oklab\_l\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_oklch\_chroma}}{gfx\_oklch\_chroma}}\label{gfx_oklch_chroma}

\texttt{gfx\_oklch\_chroma} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_oklch\_chroma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_oklch\_chroma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_oklch\_hue}}{gfx\_oklch\_hue}}\label{gfx_oklch_hue}

\texttt{gfx\_oklch\_hue} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_oklch\_hue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_oklch\_hue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_oren\_nayar\_term}}{gfx\_oren\_nayar\_term}}\label{gfx_oren_nayar_term}

\texttt{gfx\_oren\_nayar\_term} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_oren\_nayar\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_oren\_nayar\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_orthographic\_proj}}{gfx\_orthographic\_proj}}\label{gfx_orthographic_proj}

\texttt{gfx\_orthographic\_proj} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_orthographic\_proj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_orthographic\_proj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_pcg\_hash\_step}}{gfx\_pcg\_hash\_step}}\label{gfx_pcg_hash_step}

\texttt{gfx\_pcg\_hash\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_pcg\_hash\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_pcg\_hash\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_perlin\_noise\_step}}{gfx\_perlin\_noise\_step}}\label{gfx_perlin_noise_step}

\texttt{gfx\_perlin\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_perlin\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_perlin\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_perspective\_proj\_x}}{gfx\_perspective\_proj\_x}}\label{gfx_perspective_proj_x}

\texttt{gfx\_perspective\_proj\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_perspective\_proj\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_perspective\_proj\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_perspective\_proj\_y}}{gfx\_perspective\_proj\_y}}\label{gfx_perspective_proj_y}

\texttt{gfx\_perspective\_proj\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_perspective\_proj\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_perspective\_proj\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_phong\_ambient\_step}}{gfx\_phong\_ambient\_step}}\label{gfx_phong_ambient_step}

\texttt{gfx\_phong\_ambient\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_phong\_ambient\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_phong\_ambient\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_phong\_diffuse\_step}}{gfx\_phong\_diffuse\_step}}\label{gfx_phong_diffuse_step}

\texttt{gfx\_phong\_diffuse\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_phong\_diffuse\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_phong\_diffuse\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_phong\_specular\_step}}{gfx\_phong\_specular\_step}}\label{gfx_phong_specular_step}

\texttt{gfx\_phong\_specular\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_phong\_specular\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_phong\_specular\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_dot\_two}}{gfx\_quat\_dot\_two}}\label{gfx_quat_dot_two}

\texttt{gfx\_quat\_dot\_two} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_dot\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_quat\_dot\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_inverse\_step}}{gfx\_quat\_inverse\_step}}\label{gfx_quat_inverse_step}

\texttt{gfx\_quat\_inverse\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_inverse\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_quat\_inverse\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_nlerp\_step}}{gfx\_quat\_nlerp\_step}}\label{gfx_quat_nlerp_step}

\texttt{gfx\_quat\_nlerp\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_nlerp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_quat\_nlerp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_slerp\_step}}{gfx\_quat\_slerp\_step}}\label{gfx_quat_slerp_step}

\texttt{gfx\_quat\_slerp\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_slerp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_quat\_slerp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_to\_axis\_angle}}{gfx\_quat\_to\_axis\_angle}}\label{gfx_quat_to_axis_angle}

\texttt{gfx\_quat\_to\_axis\_angle} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_to\_axis\_angle $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_to\_euler\_pitch}}{gfx\_quat\_to\_euler\_pitch}}\label{gfx_quat_to_euler_pitch}

\texttt{gfx\_quat\_to\_euler\_pitch} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_to\_euler\_pitch $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_to\_euler\_roll}}{gfx\_quat\_to\_euler\_roll}}\label{gfx_quat_to_euler_roll}

\texttt{gfx\_quat\_to\_euler\_roll} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_to\_euler\_roll $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_quat\_to\_euler\_yaw}}{gfx\_quat\_to\_euler\_yaw}}\label{gfx_quat_to_euler_yaw}

\texttt{gfx\_quat\_to\_euler\_yaw} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_quat\_to\_euler\_yaw $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_radiance\_sh\_eval}}{gfx\_radiance\_sh\_eval}}\label{gfx_radiance_sh_eval}

\texttt{gfx\_radiance\_sh\_eval} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_radiance\_sh\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_radiance\_sh\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_box\_t}}{gfx\_ray\_box\_t}}\label{gfx_ray_box_t}

\texttt{gfx\_ray\_box\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_box\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_box\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_cone\_t}}{gfx\_ray\_cone\_t}}\label{gfx_ray_cone_t}

\texttt{gfx\_ray\_cone\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_cone\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_cone\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_cylinder\_t}}{gfx\_ray\_cylinder\_t}}\label{gfx_ray_cylinder_t}

\texttt{gfx\_ray\_cylinder\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_cylinder\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_cylinder\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_disk\_t}}{gfx\_ray\_disk\_t}}\label{gfx_ray_disk_t}

\texttt{gfx\_ray\_disk\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_disk\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_disk\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_ellipsoid\_t}}{gfx\_ray\_ellipsoid\_t}}\label{gfx_ray_ellipsoid_t}

\texttt{gfx\_ray\_ellipsoid\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_ellipsoid\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_ellipsoid\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_plane\_t}}{gfx\_ray\_plane\_t}}\label{gfx_ray_plane_t}

\texttt{gfx\_ray\_plane\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_plane\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_plane\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_sphere\_t}}{gfx\_ray\_sphere\_t}}\label{gfx_ray_sphere_t}

\texttt{gfx\_ray\_sphere\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_sphere\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_sphere\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_torus\_t\_approx}}{gfx\_ray\_torus\_t\_approx}}\label{gfx_ray_torus_t_approx}

\texttt{gfx\_ray\_torus\_t\_approx} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_torus\_t\_approx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_torus\_t\_approx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_ray\_triangle\_t}}{gfx\_ray\_triangle\_t}}\label{gfx_ray_triangle_t}

\texttt{gfx\_ray\_triangle\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_ray\_triangle\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_ray\_triangle\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_reflect\_direction\_x}}{gfx\_reflect\_direction\_x}}\label{gfx_reflect_direction_x}

\texttt{gfx\_reflect\_direction\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_reflect\_direction\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_reflect\_direction\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_refract\_direction\_x}}{gfx\_refract\_direction\_x}}\label{gfx_refract_direction_x}

\texttt{gfx\_refract\_direction\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_refract\_direction\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_refract\_direction\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_rotation\_matrix\_xx}}{gfx\_rotation\_matrix\_xx}}\label{gfx_rotation_matrix_xx}

\texttt{gfx\_rotation\_matrix\_xx} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_rotation\_matrix\_xx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_rotation\_matrix\_xx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_rotation\_matrix\_yy}}{gfx\_rotation\_matrix\_yy}}\label{gfx_rotation_matrix_yy}

\texttt{gfx\_rotation\_matrix\_yy} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_rotation\_matrix\_yy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_rotation\_matrix\_yy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_rotation\_matrix\_zz}}{gfx\_rotation\_matrix\_zz}}\label{gfx_rotation_matrix_zz}

\texttt{gfx\_rotation\_matrix\_zz} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_rotation\_matrix\_zz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_rotation\_matrix\_zz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_scale\_matrix\_step}}{gfx\_scale\_matrix\_step}}\label{gfx_scale_matrix_step}

\texttt{gfx\_scale\_matrix\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_scale\_matrix\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_scale\_matrix\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_screen\_space\_x}}{gfx\_screen\_space\_x}}\label{gfx_screen_space_x}

\texttt{gfx\_screen\_space\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_screen\_space\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_screen\_space\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_screen\_space\_y}}{gfx\_screen\_space\_y}}\label{gfx_screen_space_y}

\texttt{gfx\_screen\_space\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_screen\_space\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_screen\_space\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_screen\_to\_ndc\_x}}{gfx\_screen\_to\_ndc\_x}}\label{gfx_screen_to_ndc_x}

\texttt{gfx\_screen\_to\_ndc\_x} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_screen\_to\_ndc\_x $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_screen\_to\_ndc\_y}}{gfx\_screen\_to\_ndc\_y}}\label{gfx_screen_to_ndc_y}

\texttt{gfx\_screen\_to\_ndc\_y} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_screen\_to\_ndc\_y $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_shear\_matrix\_xy}}{gfx\_shear\_matrix\_xy}}\label{gfx_shear_matrix_xy}

\texttt{gfx\_shear\_matrix\_xy} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_shear\_matrix\_xy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_shear\_matrix\_xy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_signed\_distance\_box}}{gfx\_signed\_distance\_box}}\label{gfx_signed_distance_box}

\texttt{gfx\_signed\_distance\_box} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_signed\_distance\_box $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_signed\_distance\_box |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_signed\_distance\_capsule}}{gfx\_signed\_distance\_capsule}}\label{gfx_signed_distance_capsule}

\texttt{gfx\_signed\_distance\_capsule} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_signed\_distance\_capsule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_signed\_distance\_capsule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_signed\_distance\_sphere}}{gfx\_signed\_distance\_sphere}}\label{gfx_signed_distance_sphere}

\texttt{gfx\_signed\_distance\_sphere} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_signed\_distance\_sphere $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_signed\_distance\_sphere |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_simplex\_noise\_step}}{gfx\_simplex\_noise\_step}}\label{gfx_simplex_noise_step}

\texttt{gfx\_simplex\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_simplex\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_simplex\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_skybox\_uv\_u}}{gfx\_skybox\_uv\_u}}\label{gfx_skybox_uv_u}

\texttt{gfx\_skybox\_uv\_u} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_skybox\_uv\_u $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_skybox\_uv\_u |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_skybox\_uv\_v}}{gfx\_skybox\_uv\_v}}\label{gfx_skybox_uv_v}

\texttt{gfx\_skybox\_uv\_v} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_skybox\_uv\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_skybox\_uv\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_snells\_law\_angle}}{gfx\_snells\_law\_angle}}\label{gfx_snells_law_angle}

\texttt{gfx\_snells\_law\_angle} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_snells\_law\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_snells\_law\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_sobol\_step}}{gfx\_sobol\_step}}\label{gfx_sobol_step}

\texttt{gfx\_sobol\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_sobol\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_sobol\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_sphere\_intersect\_t}}{gfx\_sphere\_intersect\_t}}\label{gfx_sphere_intersect_t}

\texttt{gfx\_sphere\_intersect\_t} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_sphere\_intersect\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_sphere\_intersect\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_spherical\_harmonic\_y00}}{gfx\_spherical\_harmonic\_y00}}\label{gfx_spherical_harmonic_y00}

\texttt{gfx\_spherical\_harmonic\_y00} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_spherical\_harmonic\_y00 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_spherical\_harmonic\_y00 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_spherical\_harmonic\_y10}}{gfx\_spherical\_harmonic\_y10}}\label{gfx_spherical_harmonic_y10}

\texttt{gfx\_spherical\_harmonic\_y10} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_spherical\_harmonic\_y10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_spherical\_harmonic\_y10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_spherical\_harmonic\_y11}}{gfx\_spherical\_harmonic\_y11}}\label{gfx_spherical_harmonic_y11}

\texttt{gfx\_spherical\_harmonic\_y11} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_spherical\_harmonic\_y11 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_spherical\_harmonic\_y11 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_spherical\_harmonic\_y20}}{gfx\_spherical\_harmonic\_y20}}\label{gfx_spherical_harmonic_y20}

\texttt{gfx\_spherical\_harmonic\_y20} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_spherical\_harmonic\_y20 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_spherical\_harmonic\_y20 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_srgb\_to\_linear}}{gfx\_srgb\_to\_linear}}\label{gfx_srgb_to_linear}

\texttt{gfx\_srgb\_to\_linear} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_srgb\_to\_linear $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_subsurface\_scattering\_term}}{gfx\_subsurface\_scattering\_term}}\label{gfx_subsurface_scattering_term}

\texttt{gfx\_subsurface\_scattering\_term} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_subsurface\_scattering\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_subsurface\_scattering\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_sutherland\_hodgman}}{gfx\_sutherland\_hodgman}}\label{gfx_sutherland_hodgman}

\texttt{gfx\_sutherland\_hodgman} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_sutherland\_hodgman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_sutherland\_hodgman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_tonemap\_aces}}{gfx\_tonemap\_aces}}\label{gfx_tonemap_aces}

\texttt{gfx\_tonemap\_aces} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_tonemap\_aces $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_tonemap\_aces |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_tonemap\_filmic}}{gfx\_tonemap\_filmic}}\label{gfx_tonemap_filmic}

\texttt{gfx\_tonemap\_filmic} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_tonemap\_filmic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_tonemap\_filmic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_tonemap\_reinhard}}{gfx\_tonemap\_reinhard}}\label{gfx_tonemap_reinhard}

\texttt{gfx\_tonemap\_reinhard} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_tonemap\_reinhard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_tonemap\_reinhard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_tonemap\_uncharted2}}{gfx\_tonemap\_uncharted2}}\label{gfx_tonemap_uncharted2}

\texttt{gfx\_tonemap\_uncharted2} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_tonemap\_uncharted2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_tonemap\_uncharted2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_total\_internal\_reflection}}{gfx\_total\_internal\_reflection}}\label{gfx_total_internal_reflection}

\texttt{gfx\_total\_internal\_reflection} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_total\_internal\_reflection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_total\_internal\_reflection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_translation\_matrix\_step}}{gfx\_translation\_matrix\_step}}\label{gfx_translation_matrix_step}

\texttt{gfx\_translation\_matrix\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_translation\_matrix\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_translation\_matrix\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_translucent\_falloff}}{gfx\_translucent\_falloff}}\label{gfx_translucent_falloff}

\texttt{gfx\_translucent\_falloff} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_translucent\_falloff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_translucent\_falloff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_value\_noise\_step}}{gfx\_value\_noise\_step}}\label{gfx_value_noise_step}

\texttt{gfx\_value\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_value\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_value\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_van\_der\_corput}}{gfx\_van\_der\_corput}}\label{gfx_van_der_corput}

\texttt{gfx\_van\_der\_corput} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_van\_der\_corput $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_van\_der\_corput |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_view\_matrix\_step}}{gfx\_view\_matrix\_step}}\label{gfx_view_matrix_step}

\texttt{gfx\_view\_matrix\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_view\_matrix\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_view\_matrix\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_voronoi\_distance}}{gfx\_voronoi\_distance}}\label{gfx_voronoi_distance}

\texttt{gfx\_voronoi\_distance} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_voronoi\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_voronoi\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_worley\_noise\_step}}{gfx\_worley\_noise\_step}}\label{gfx_worley_noise_step}

\texttt{gfx\_worley\_noise\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_worley\_noise\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_worley\_noise\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_xiaolin\_wu\_intensity}}{gfx\_xiaolin\_wu\_intensity}}\label{gfx_xiaolin_wu_intensity}

\texttt{gfx\_xiaolin\_wu\_intensity} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_xiaolin\_wu\_intensity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_xiaolin\_wu\_intensity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_xorshift\_step}}{gfx\_xorshift\_step}}\label{gfx_xorshift_step}

\texttt{gfx\_xorshift\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_xorshift\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_xorshift\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gfx\_zonal\_harmonic\_step}}{gfx\_zonal\_harmonic\_step}}\label{gfx_zonal_harmonic_step}

\texttt{gfx\_zonal\_harmonic\_step} --- batch 47 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gfx\_zonal\_harmonic\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gfx\_zonal\_harmonic\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ghz\_state}}{ghz\_state}}\label{ghz_state}

\texttt{ghz\_state} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ghz\_state $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ghz\_state |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ghz\_state\_n}}{ghz\_state\_n}}\label{ghz_state_n}

\texttt{ghz\_state\_n} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ghz\_state\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ghz\_state\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gibbard\_satterthwaite\_check}}{gibbard\_satterthwaite\_check}}\label{gibbard_satterthwaite_check}

\texttt{gibbard\_satterthwaite\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gibbard\_satterthwaite\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gibbard\_satterthwaite\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gibbs\_thomson\_undercooling}}{gibbs\_thomson\_undercooling}}\label{gibbs_thomson_undercooling}

\texttt{gibbs\_thomson\_undercooling} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gibbs\_thomson\_undercooling $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gibbs\_thomson\_undercooling |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gid}}{gid}}\label{gid}

\texttt{gid} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gin}}{gin}}\label{gin}

\texttt{gin} --- algebraic match builtin. Alias for \texttt{get\_in}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gini}}{gini}}\label{gini}

\texttt{gini(@data)} (alias \texttt{gini\_coefficient}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p gini(1, 1, 1, 1)     \# 0 (perfect equality)}
\NormalTok{p gini(0, 0, 0, 100)   \# \textasciitilde{}0.75 (high inequality)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gini\_impurity}}{gini\_impurity}}\label{gini_impurity}

\texttt{gini\_impurity} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gini\_impurity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gini\_impurity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gini\_inequality\_health}}{gini\_inequality\_health}}\label{gini_inequality_health}

\texttt{gini\_inequality\_health} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gini\_inequality\_health $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gini\_inequality\_health |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gini\_market}}{gini\_market}}\label{gini_market}

\texttt{gini\_market} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gini\_market $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gini\_market |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{girth}}{girth}}\label{girth}

\texttt{girth} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = girth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map girth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{girvan\_newman}}{girvan\_newman}}\label{girvan_newman}

\texttt{girvan\_newman} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = girvan\_newman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map girvan\_newman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gk15}}{gk15}}\label{gk15}

\texttt{gk15} --- batch 19 builtin. Alias for
\texttt{gauss\_kronrod\_15}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gk15 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gk15 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gl5}}{gl5}}\label{gl5}

\texttt{gl5} --- batch 19 builtin. Alias for
\texttt{gauss\_legendre\_5}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gl5 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gl5 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glaisher}}{glaisher}}\label{glaisher}

\texttt{glaisher} --- math constants builtin. Alias for
\texttt{glaisher\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = glaisher $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map glaisher |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glaisher\_constant}}{glaisher\_constant}}\label{glaisher_constant}

\texttt{glaisher\_constant} --- math constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = glaisher\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map glaisher\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glicko\_rating}}{glicko\_rating}}\label{glicko_rating}

\texttt{glicko\_rating} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = glicko\_rating $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map glicko\_rating |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glm}}{glm}}\label{glm}

\texttt{glm} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = glm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map glm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glob\_to\_regex}}{glob\_to\_regex}}\label{glob_to_regex}

\texttt{glob\_to\_regex} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = glob\_to\_regex $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{global\_efficiency}}{global\_efficiency}}\label{global_efficiency}

\texttt{global\_efficiency} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = global\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map global\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{glushkov\_construction}}{glushkov\_construction}}\label{glushkov_construction}

\texttt{glushkov\_construction} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = glushkov\_construction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map glushkov\_construction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gmm\_moment\_condition}}{gmm\_moment\_condition}}\label{gmm_moment_condition}

\texttt{gmm\_moment\_condition} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gmm\_moment\_condition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gmm\_moment\_condition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gmm\_moment\_function}}{gmm\_moment\_function}}\label{gmm_moment_function}

\texttt{gmm\_moment\_function} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gmm\_moment\_function $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gmm\_moment\_function |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{go\_enrichment\_p}}{go\_enrichment\_p}}\label{go_enrichment_p}

\texttt{go\_enrichment\_p} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = go\_enrichment\_p $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map go\_enrichment\_p |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goals\_above\_avg}}{goals\_above\_avg}}\label{goals_above_avg}

\texttt{goals\_above\_avg} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = goals\_above\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map goals\_above\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goertzel}}{goertzel}}\label{goertzel}

\texttt{goertzel} computes the magnitude of a single DFT frequency bin
using the Goertzel algorithm. Much faster than full FFT when you need
one frequency.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $mag = goertzel(\textbackslash{}@signal, 440, 44100)  \# 440 Hz component}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goldb}}{goldb}}\label{goldb}

\texttt{goldb} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{goldbach}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = goldb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map goldb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goldbach}}{goldbach}}\label{goldbach}

\texttt{goldbach} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = goldbach $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map goldbach |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goldbach\_pair}}{goldbach\_pair}}\label{goldbach_pair}

\texttt{goldbach\_pair} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = goldbach\_pair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map goldbach\_pair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{golden}}{golden}}\label{golden}

\texttt{golden\_section} (aliases \texttt{golden}, \texttt{gss}) finds
the minimum of f on {[}a,b{]} via golden-section search.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $xmin = golden(fn \{ ($\_[0]{-}3)**2 \}, 0, 10)  \# 3.0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{golden\_ratio}}{golden\_ratio}}\label{golden_ratio}

\texttt{golden\_ratio} (alias \texttt{phi}) --- φ = (1+√5)/2 ≈ 1.618.
The golden ratio, appears throughout nature and art.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p phi   \# 1.618033988749895}
\NormalTok{\# Fibonacci limit: fib(n)/fib(n{-}1) → φ}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goldfeld\_quandt}}{goldfeld\_quandt}}\label{goldfeld_quandt}

\texttt{goldfeld\_quandt} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = goldfeld\_quandt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map goldfeld\_quandt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{golomb\_rice\_code}}{golomb\_rice\_code}}\label{golomb_rice_code}

\texttt{golomb\_rice\_code} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = golomb\_rice\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map golomb\_rice\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{golstep}}{golstep}}\label{golstep}

\texttt{golstep} --- algorithms / puzzles builtin. Alias for
\texttt{game\_of\_life\_step}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = golstep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map golstep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gomory\_cut\_step}}{gomory\_cut\_step}}\label{gomory_cut_step}

\texttt{gomory\_cut\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gomory\_cut\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gomory\_cut\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gomory\_hu\_step}}{gomory\_hu\_step}}\label{gomory_hu_step}

\texttt{gomory\_hu\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gomory\_hu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gomory\_hu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gompertz\_growth\_step}}{gompertz\_growth\_step}}\label{gompertz_growth_step}

\texttt{gompertz\_growth\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gompertz\_growth\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gompertz\_growth\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gompertz\_pdf}}{gompertz\_pdf}}\label{gompertz_pdf}

\texttt{gompertz\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gompertz\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gompertz\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{goto}}{goto}}\label{goto}

\texttt{goto} --- control flow builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = goto $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map goto |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gouy\_chapman\_potential}}{gouy\_chapman\_potential}}\label{gouy_chapman_potential}

\texttt{gouy\_chapman\_potential} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gouy\_chapman\_potential $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gouy\_chapman\_potential |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gradient\_descent\_step}}{gradient\_descent\_step}}\label{gradient_descent_step}

\texttt{gradient\_descent\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gradient\_descent\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gradient\_descent\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gradient\_geothermal}}{gradient\_geothermal}}\label{gradient_geothermal}

\texttt{gradient\_geothermal} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gradient\_geothermal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gradient\_geothermal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gradient\_richardson\_full}}{gradient\_richardson\_full}}\label{gradient_richardson_full}

\texttt{gradient\_richardson\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gradient\_richardson\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gradient\_richardson\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gradient\_temporal\_diff}}{gradient\_temporal\_diff}}\label{gradient_temporal_diff}

\texttt{gradient\_temporal\_diff} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gradient\_temporal\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gradient\_temporal\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gradient\_wind\_step}}{gradient\_wind\_step}}\label{gradient_wind_step}

\texttt{gradient\_wind\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gradient\_wind\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gradient\_wind\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graham\_2approx\_bound}}{graham\_2approx\_bound}}\label{graham_2approx_bound}

\texttt{graham\_2approx\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graham\_2approx\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graham\_2approx\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gram\_schmidt}}{gram\_schmidt}}\label{gram_schmidt}

\texttt{gram\_schmidt} --- batch 11 builtin. Alias for
\texttt{orthogonalize\_vectors}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gram\_schmidt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gram\_schmidt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{granger\_causality}}{granger\_causality}}\label{granger_causality}

\texttt{granger\_causality} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = granger\_causality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map granger\_causality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{granger\_causality\_chi2}}{granger\_causality\_chi2}}\label{granger_causality_chi2}

\texttt{granger\_causality\_chi2} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = granger\_causality\_chi2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map granger\_causality\_chi2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_average\_degree}}{graph\_average\_degree}}\label{graph_average_degree}

\texttt{graph\_average\_degree} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_average\_degree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_average\_degree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_avg\_clustering}}{graph\_avg\_clustering}}\label{graph_avg_clustering}

\texttt{graph\_avg\_clustering} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_avg\_clustering $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_avg\_clustering |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_bipartite\_match\_simple}}{graph\_bipartite\_match\_simple}}\label{graph_bipartite_match_simple}

\texttt{graph\_bipartite\_match\_simple} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_bipartite\_match\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_bipartite\_match\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_coloring\_brooks\_bound}}{graph\_coloring\_brooks\_bound}}\label{graph_coloring_brooks_bound}

\texttt{graph\_coloring\_brooks\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_coloring\_brooks\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_coloring\_brooks\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_coloring\_dsatur\_step}}{graph\_coloring\_dsatur\_step}}\label{graph_coloring_dsatur_step}

\texttt{graph\_coloring\_dsatur\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_coloring\_dsatur\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_coloring\_dsatur\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_coloring\_greedy}}{graph\_coloring\_greedy}}\label{graph_coloring_greedy}

\texttt{graph\_coloring\_greedy} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_coloring\_greedy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_coloring\_greedy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_coloring\_lp\_bound}}{graph\_coloring\_lp\_bound}}\label{graph_coloring_lp_bound}

\texttt{graph\_coloring\_lp\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_coloring\_lp\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_coloring\_lp\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_coloring\_welsh\_powell}}{graph\_coloring\_welsh\_powell}}\label{graph_coloring_welsh_powell}

\texttt{graph\_coloring\_welsh\_powell} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_coloring\_welsh\_powell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_coloring\_welsh\_powell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_complement}}{graph\_complement}}\label{graph_complement}

\texttt{graph\_complement} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_complement $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_complement |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_count\_edges}}{graph\_count\_edges}}\label{graph_count_edges}

\texttt{graph\_count\_edges} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_count\_edges $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_count\_edges |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_count\_paths\_length\_k}}{graph\_count\_paths\_length\_k}}\label{graph_count_paths_length_k}

\texttt{graph\_count\_paths\_length\_k} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_count\_paths\_length\_k $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_count\_paths\_length\_k |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_count\_triangles}}{graph\_count\_triangles}}\label{graph_count_triangles}

\texttt{graph\_count\_triangles} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_count\_triangles $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_count\_triangles |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_cut\_segment}}{graph\_cut\_segment}}\label{graph_cut_segment}

\texttt{graph\_cut\_segment} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_cut\_segment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_cut\_segment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_degree\_distribution}}{graph\_degree\_distribution}}\label{graph_degree_distribution}

\texttt{graph\_degree\_distribution} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_degree\_distribution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_degree\_distribution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_density}}{graph\_density}}\label{graph_density}

\texttt{graph\_density} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_eccentricity\_all}}{graph\_eccentricity\_all}}\label{graph_eccentricity_all}

\texttt{graph\_eccentricity\_all} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_eccentricity\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_eccentricity\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_independent\_set\_brute}}{graph\_independent\_set\_brute}}\label{graph_independent_set_brute}

\texttt{graph\_independent\_set\_brute} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_independent\_set\_brute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_independent\_set\_brute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_is\_tree}}{graph\_is\_tree}}\label{graph_is_tree}

\texttt{graph\_is\_tree} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_is\_tree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_is\_tree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_max\_clique\_brute}}{graph\_max\_clique\_brute}}\label{graph_max_clique_brute}

\texttt{graph\_max\_clique\_brute} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_max\_clique\_brute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_max\_clique\_brute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_max\_degree}}{graph\_max\_degree}}\label{graph_max_degree}

\texttt{graph\_max\_degree} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_max\_degree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_max\_degree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_min\_degree}}{graph\_min\_degree}}\label{graph_min_degree}

\texttt{graph\_min\_degree} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_min\_degree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_min\_degree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_pagerank\_simple}}{graph\_pagerank\_simple}}\label{graph_pagerank_simple}

\texttt{graph\_pagerank\_simple} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_pagerank\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_pagerank\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{graph\_transitivity}}{graph\_transitivity}}\label{graph_transitivity}

\texttt{graph\_transitivity} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = graph\_transitivity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map graph\_transitivity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grashof\_number}}{grashof\_number}}\label{grashof_number}

\texttt{grashof\_number} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grashof\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grashof\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grashof\_number\_step}}{grashof\_number\_step}}\label{grashof_number_step}

\texttt{grashof\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grashof\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grashof\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grav\_binding\_energy}}{grav\_binding\_energy}}\label{grav_binding_energy}

\texttt{grav\_binding\_energy} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grav\_binding\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grav\_binding\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grav\_dilation\_factor}}{grav\_dilation\_factor}}\label{grav_dilation_factor}

\texttt{grav\_dilation\_factor} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grav\_dilation\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grav\_dilation\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grav\_redshift}}{grav\_redshift}}\label{grav_redshift}

\texttt{grav\_redshift} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grav\_redshift $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grav\_redshift |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grav\_time\_dilation}}{grav\_time\_dilation}}\label{grav_time_dilation}

\texttt{grav\_time\_dilation} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grav\_time\_dilation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grav\_time\_dilation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gravitational\_constant}}{gravitational\_constant}}\label{gravitational_constant}

\texttt{gravitational\_constant} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gravitational\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gravitational\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gravitational\_pe}}{gravitational\_pe}}\label{gravitational_pe}

\texttt{gravitational\_pe} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gravitational\_pe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gravitational\_pe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gravitational\_wave\_quadrupole}}{gravitational\_wave\_quadrupole}}\label{gravitational_wave_quadrupole}

\texttt{gravitational\_wave\_quadrupole} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gravitational\_wave\_quadrupole $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gravitational\_wave\_quadrupole |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gravity}}{gravity}}\label{gravity}

\texttt{gravity} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gravity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gravity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gravity\_at\_radius}}{gravity\_at\_radius}}\label{gravity_at_radius}

\texttt{gravity\_at\_radius} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gravity\_at\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gravity\_at\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gray}}{gray}}\label{gray}

\texttt{gray} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gray $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gray |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gray2b}}{gray2b}}\label{gray2b}

\texttt{gray2b} --- base / gray code builtin. Alias for
\texttt{gray\_to\_binary}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gray2b $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gray2b |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gray\_code\_sequence}}{gray\_code\_sequence}}\label{gray_code_sequence}

\texttt{gray\_code\_sequence} --- base / gray code builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gray\_code\_sequence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gray\_code\_sequence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gray\_to\_bin}}{gray\_to\_bin}}\label{gray_to_bin}

\texttt{gray\_to\_bin} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gray\_to\_bin $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gray\_to\_binary}}{gray\_to\_binary}}\label{gray_to_binary}

\texttt{gray\_to\_binary} --- base / gray code builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gray\_to\_binary $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grayseq}}{grayseq}}\label{grayseq}

\texttt{grayseq} --- base / gray code builtin. Alias for
\texttt{gray\_code\_sequence}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grayseq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grayseq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{great\_circle\_law\_of\_cos}}{great\_circle\_law\_of\_cos}}\label{great_circle_law_of_cos}

\texttt{great\_circle\_law\_of\_cos} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = great\_circle\_law\_of\_cos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map great\_circle\_law\_of\_cos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{greedy\_coloring}}{greedy\_coloring}}\label{greedy_coloring}

\texttt{greedy\_coloring} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = greedy\_coloring $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map greedy\_coloring |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{greedy\_edge\_tour}}{greedy\_edge\_tour}}\label{greedy_edge_tour}

\texttt{greedy\_edge\_tour} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = greedy\_edge\_tour $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map greedy\_edge\_tour |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{greedy\_set\_cover\_round}}{greedy\_set\_cover\_round}}\label{greedy_set_cover_round}

\texttt{greedy\_set\_cover\_round} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = greedy\_set\_cover\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map greedy\_set\_cover\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{green}}{green}}\label{green}

\texttt{green} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = green $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map green |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{green\_bold}}{green\_bold}}\label{green_bold}

\texttt{green\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = green\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map green\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{greenhouse\_forcing\_step}}{greenhouse\_forcing\_step}}\label{greenhouse_forcing_step}

\texttt{greenhouse\_forcing\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = greenhouse\_forcing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map greenhouse\_forcing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gregorian\_from\_fixed}}{gregorian\_from\_fixed}}\label{gregorian_from_fixed}

\texttt{gregorian\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gregorian\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gregorian\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grepv}}{grepv}}\label{grepv}

\texttt{grepv} --- functional / iterator builtin. Alias for
\texttt{take\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grepv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grepv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grey}}{grey}}\label{grey}

\texttt{grey} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grey $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grey |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grim\_trigger\_step}}{grim\_trigger\_step}}\label{grim_trigger_step}

\texttt{grim\_trigger\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grim\_trigger\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grim\_trigger\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gromov\_wasserstein\_step}}{gromov\_wasserstein\_step}}\label{gromov_wasserstein_step}

\texttt{gromov\_wasserstein\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gromov\_wasserstein\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gromov\_wasserstein\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gromov\_witten\_invariant}}{gromov\_witten\_invariant}}\label{gromov_witten_invariant}

\texttt{gromov\_witten\_invariant} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gromov\_witten\_invariant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gromov\_witten\_invariant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gross\_premium\_load}}{gross\_premium\_load}}\label{gross_premium_load}

\texttt{gross\_premium\_load} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gross\_premium\_load $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gross\_premium\_load |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_by}}{group\_by}}\label{group_by}

\texttt{group\_by} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_by\_fn}}{group\_by\_fn}}\label{group_by_fn}

\texttt{group\_by\_fn} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_by\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_by\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_by\_size}}{group\_by\_size}}\label{group_by_size}

\texttt{group\_by\_size} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_by\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_by\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_cohomology\_dim}}{group\_cohomology\_dim}}\label{group_cohomology_dim}

\texttt{group\_cohomology\_dim} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_cohomology\_dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_cohomology\_dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_consecutive}}{group\_consecutive}}\label{group_consecutive}

\texttt{group\_consecutive} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_consecutive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_consecutive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_consecutive\_by}}{group\_consecutive\_by}}\label{group_consecutive_by}

\texttt{group\_consecutive\_by} --- matrix operations (uncategorized
batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_consecutive\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_consecutive\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_delay\_eval}}{group\_delay\_eval}}\label{group_delay_eval}

\texttt{group\_delay\_eval} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_delay\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_delay\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_homology\_dim}}{group\_homology\_dim}}\label{group_homology_dim}

\texttt{group\_homology\_dim} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_homology\_dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_homology\_dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_number}}{group\_number}}\label{group_number}

\texttt{group\_number} --- file stat / path builtin. Alias for
\texttt{format\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_of\_n}}{group\_of\_n}}\label{group_of_n}

\texttt{group\_of\_n} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_of\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_of\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{group\_runs}}{group\_runs}}\label{group_runs}

\texttt{group\_runs} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = group\_runs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map group\_runs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{groupby\_iter}}{groupby\_iter}}\label{groupby_iter}

\texttt{groupby\_iter} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = groupby\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map groupby\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{grover\_iter}}{grover\_iter}}\label{grover_iter}

\texttt{grover\_iter} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = grover\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map grover\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{growing\_perpetuity}}{growing\_perpetuity}}\label{growing_perpetuity}

\texttt{growing\_perpetuity} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = growing\_perpetuity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map growing\_perpetuity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{growth\_rate\_from\_ratio}}{growth\_rate\_from\_ratio}}\label{growth_rate_from_ratio}

\texttt{growth\_rate\_from\_ratio} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = growth\_rate\_from\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map growth\_rate\_from\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gruns}}{gruns}}\label{gruns}

\texttt{gruns} --- haskell list functions builtin. Alias for
\texttt{group\_runs}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gruns $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gruns |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gullstrand\_painleve\_step}}{gullstrand\_painleve\_step}}\label{gullstrand_painleve_step}

\texttt{gullstrand\_painleve\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gullstrand\_painleve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gullstrand\_painleve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gunning\_fog}}{gunning\_fog}}\label{gunning_fog}

\texttt{gunning\_fog} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gunning\_fog $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gunning\_fog |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gutenberg\_richter\_b}}{gutenberg\_richter\_b}}\label{gutenberg_richter_b}

\texttt{gutenberg\_richter\_b} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gutenberg\_richter\_b $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gutenberg\_richter\_b |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gw\_strain\_amplitude}}{gw\_strain\_amplitude}}\label{gw_strain_amplitude}

\texttt{gw\_strain\_amplitude} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gw\_strain\_amplitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gw\_strain\_amplitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gx\_diameter}}{gx\_diameter}}\label{gx_diameter}

\texttt{gx\_diameter} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gx\_diameter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gx\_diameter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gx\_eccentricity}}{gx\_eccentricity}}\label{gx_eccentricity}

\texttt{gx\_eccentricity} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gx\_eccentricity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gx\_eccentricity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gx\_radius}}{gx\_radius}}\label{gx_radius}

\texttt{gx\_radius} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gx\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gx\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gz}}{gz}}\label{gz}

\texttt{gz} --- crypto / encoding builtin. Alias for \texttt{gzip}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gzip\_crc32\_init}}{gzip\_crc32\_init}}\label{gzip_crc32_init}

\texttt{gzip\_crc32\_init} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gzip\_crc32\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gzip\_crc32\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gzip\_encode\_step}}{gzip\_encode\_step}}\label{gzip_encode_step}

\texttt{gzip\_encode\_step} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gzip\_encode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gzip\_encode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gzip\_isize}}{gzip\_isize}}\label{gzip_isize}

\texttt{gzip\_isize} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gzip\_isize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gzip\_isize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{gzip\_member\_step}}{gzip\_member\_step}}\label{gzip_member_step}

\texttt{gzip\_member\_step} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = gzip\_member\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map gzip\_member\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h0}}{h0}}\label{h0}

\texttt{h0} --- physics constants builtin. Alias for
\texttt{hubble\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map h0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h3\_geo\_to\_h3}}{h3\_geo\_to\_h3}}\label{h3_geo_to_h3}

\texttt{h3\_geo\_to\_h3} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h3\_geo\_to\_h3 $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h3\_h3\_to\_geo}}{h3\_h3\_to\_geo}}\label{h3_h3_to_geo}

\texttt{h3\_h3\_to\_geo} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h3\_h3\_to\_geo $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h3\_index}}{h3\_index}}\label{h3_index}

\texttt{h3\_index} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h3\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map h3\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h3\_k\_ring}}{h3\_k\_ring}}\label{h3_k_ring}

\texttt{h3\_k\_ring} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h3\_k\_ring $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map h3\_k\_ring |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h3\_neighbor}}{h3\_neighbor}}\label{h3_neighbor}

\texttt{h3\_neighbor} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h3\_neighbor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map h3\_neighbor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h3\_resolution}}{h3\_resolution}}\label{h3_resolution}

\texttt{h3\_resolution} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h3\_resolution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map h3\_resolution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{h\_infinity\_norm}}{h\_infinity\_norm}}\label{h_infinity_norm}

\texttt{h\_infinity\_norm} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = h\_infinity\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map h\_infinity\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{haar\_2d\_step}}{haar\_2d\_step}}\label{haar_2d_step}

\texttt{haar\_2d\_step} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = haar\_2d\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map haar\_2d\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hadamard\_walsh\_transform\_step}}{hadamard\_walsh\_transform\_step}}\label{hadamard_walsh_transform_step}

\texttt{hadamard\_walsh\_transform\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hadamard\_walsh\_transform\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hadamard\_walsh\_transform\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hadley\_cell\_max\_lat}}{hadley\_cell\_max\_lat}}\label{hadley_cell_max_lat}

\texttt{hadley\_cell\_max\_lat} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hadley\_cell\_max\_lat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hadley\_cell\_max\_lat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hagen\_poiseuille\_eo}}{hagen\_poiseuille\_eo}}\label{hagen_poiseuille_eo}

\texttt{hagen\_poiseuille\_eo} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hagen\_poiseuille\_eo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hagen\_poiseuille\_eo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{half}}{half}}\label{half}

\texttt{half} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = half $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map half |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{half\_cauchy\_pdf}}{half\_cauchy\_pdf}}\label{half_cauchy_pdf}

\texttt{half\_cauchy\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = half\_cauchy\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map half\_cauchy\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{half\_each}}{half\_each}}\label{half_each}

\texttt{half\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = half\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map half\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{half\_logistic\_pdf}}{half\_logistic\_pdf}}\label{half_logistic_pdf}

\texttt{half\_logistic\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = half\_logistic\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map half\_logistic\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{half\_reaction\_balance}}{half\_reaction\_balance}}\label{half_reaction_balance}

\texttt{half\_reaction\_balance} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = half\_reaction\_balance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map half\_reaction\_balance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hall\_inner\_product\_two}}{hall\_inner\_product\_two}}\label{hall_inner_product_two}

\texttt{hall\_inner\_product\_two} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hall\_inner\_product\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hall\_inner\_product\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{halley}}{halley}}\label{halley}

\texttt{halley} --- batch 19 builtin. Alias for \texttt{halley\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = halley $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map halley |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{halley\_root}}{halley\_root}}\label{halley_root}

\texttt{halley\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = halley\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map halley\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamdist}}{hamdist}}\label{hamdist}

\texttt{hamdist} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamdist\_int}}{hamdist\_int}}\label{hamdist_int}

\texttt{hamdist\_int} --- batch 10 builtin. Alias for
\texttt{hamming\_distance\_int}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamdist\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamdist\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamiltonian\_brute}}{hamiltonian\_brute}}\label{hamiltonian_brute}

\texttt{hamiltonian\_brute} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamiltonian\_brute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamiltonian\_brute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamiltonian\_path}}{hamiltonian\_path}}\label{hamiltonian_path}

\texttt{hamiltonian\_path} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamiltonian\_path $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamiltonian\_path |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming}}{hamming}}\label{hamming}

\texttt{window\_hamming(\$n)} (alias \texttt{hamming}) --- generates a
Hamming window of length n. Similar to Hann but with slightly different
coefficients, optimized for speech processing.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $w = hamming(1024)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_distance}}{hamming\_distance}}\label{hamming_distance}

\texttt{hamming\_distance} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_distance\_int}}{hamming\_distance\_int}}\label{hamming_distance_int}

\texttt{hamming\_distance\_int} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_distance\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_distance\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_distance\_str}}{hamming\_distance\_str}}\label{hamming_distance_str}

\texttt{hamming\_distance\_str} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_distance\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_distance\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_protein}}{hamming\_protein}}\label{hamming_protein}

\texttt{hamming\_protein} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_protein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_protein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_w}}{hamming\_w}}\label{hamming_w}

\texttt{hamming\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_weight}}{hamming\_weight}}\label{hamming_weight}

\texttt{hamming\_weight} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_weight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_weight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hamming\_window}}{hamming\_window}}\label{hamming_window}

\texttt{hamming\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hamming\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hamming\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hann}}{hann}}\label{hann}

\texttt{window\_hann(\$n)} (alias \texttt{hann}) --- generates a Hann
(raised cosine) window of length n. Common window function for spectral
analysis that reduces spectral leakage.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $w = hann(1024)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hann\_w}}{hann\_w}}\label{hann_w}

\texttt{hann\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hann\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hann\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hann\_window}}{hann\_window}}\label{hann_window}

\texttt{hann\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hann\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hann\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hannan\_quinn\_ic}}{hannan\_quinn\_ic}}\label{hannan_quinn_ic}

\texttt{hannan\_quinn\_ic} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hannan\_quinn\_ic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hannan\_quinn\_ic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hanoi}}{hanoi}}\label{hanoi}

\texttt{hanoi} --- algorithms / puzzles builtin. Alias for
\texttt{tower\_of\_hanoi}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hanoi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hanoi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hansen\_j\_test}}{hansen\_j\_test}}\label{hansen_j_test}

\texttt{hansen\_j\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hansen\_j\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hansen\_j\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hard\_sigmoid}}{hard\_sigmoid}}\label{hard_sigmoid}

\texttt{hard\_sigmoid} --- ml activation functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hard\_sigmoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hard\_sigmoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hard\_swish}}{hard\_swish}}\label{hard_swish}

\texttt{hard\_swish} --- ml activation functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hard\_swish $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hard\_swish |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hardsigmoid}}{hardsigmoid}}\label{hardsigmoid}

\texttt{hardsigmoid} --- ml activation functions builtin. Alias for
\texttt{hard\_sigmoid}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hardsigmoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hardsigmoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hardswish}}{hardswish}}\label{hardswish}

\texttt{hardswish} --- ml activation functions builtin. Alias for
\texttt{hard\_swish}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hardswish $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hardswish |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonic}}{harmonic}}\label{harmonic}

\texttt{harmonic\_number} (alias \texttt{harmonic}) computes the nth
harmonic number H\_n = 1 + 1/2 + 1/3 + ... + 1/n.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p harmonic(1)    \# 1.0}
\NormalTok{p harmonic(10)   \# 2.9290}
\NormalTok{p harmonic(100)  \# 5.1874}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonic\_centrality}}{harmonic\_centrality}}\label{harmonic_centrality}

\texttt{harmonic\_centrality} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harmonic\_centrality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harmonic\_centrality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonic\_mean}}{harmonic\_mean}}\label{harmonic_mean}

\texttt{harmonic\_mean} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harmonic\_mean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harmonic\_mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonic\_mean\_arr}}{harmonic\_mean\_arr}}\label{harmonic_mean_arr}

\texttt{harmonic\_mean\_arr} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harmonic\_mean\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harmonic\_mean\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonic\_oscillator\_energy}}{harmonic\_oscillator\_energy}}\label{harmonic_oscillator_energy}

\texttt{harmonic\_oscillator\_energy} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harmonic\_oscillator\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harmonic\_oscillator\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonic\_seq\_sum}}{harmonic\_seq\_sum}}\label{harmonic_seq_sum}

\texttt{harmonic\_seq\_sum} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harmonic\_seq\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harmonic\_seq\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harmonics\_partial}}{harmonics\_partial}}\label{harmonics_partial}

\texttt{harmonics\_partial} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harmonics\_partial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harmonics\_partial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{harris\_corners}}{harris\_corners}}\label{harris_corners}

\texttt{harris\_corners} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = harris\_corners $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map harris\_corners |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hartle\_thorne\_metric}}{hartle\_thorne\_metric}}\label{hartle_thorne_metric}

\texttt{hartle\_thorne\_metric} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hartle\_thorne\_metric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hartle\_thorne\_metric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_all\_keys}}{has\_all\_keys}}\label{has_all_keys}

\texttt{has\_all\_keys} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_all\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_all\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_any\_key}}{has\_any\_key}}\label{has_any_key}

\texttt{has\_any\_key} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_any\_key $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_any\_key |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_cycle\_directed}}{has\_cycle\_directed}}\label{has_cycle_directed}

\texttt{has\_cycle\_directed} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_cycle\_directed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_cycle\_directed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_cycle\_graph}}{has\_cycle\_graph}}\label{has_cycle_graph}

\texttt{has\_cycle\_graph} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_cycle\_graph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_cycle\_graph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_cycle\_undirected}}{has\_cycle\_undirected}}\label{has_cycle_undirected}

\texttt{has\_cycle\_undirected} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_cycle\_undirected $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_cycle\_undirected |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_duplicates}}{has\_duplicates}}\label{has_duplicates}

\texttt{has\_duplicates} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_duplicates $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_duplicates |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_key}}{has\_key}}\label{has_key}

\texttt{has\_key} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_key $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_key |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_stderr\_tty}}{has\_stderr\_tty}}\label{has_stderr_tty}

\texttt{has\_stderr\_tty} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_stderr\_tty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_stderr\_tty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_stdin\_tty}}{has\_stdin\_tty}}\label{has_stdin_tty}

\texttt{has\_stdin\_tty} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_stdin\_tty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_stdin\_tty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{has\_stdout\_tty}}{has\_stdout\_tty}}\label{has_stdout_tty}

\texttt{has\_stdout\_tty} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = has\_stdout\_tty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map has\_stdout\_tty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hascyc}}{hascyc}}\label{hascyc}

\texttt{hascyc} --- extended stdlib builtin. Alias for
\texttt{has\_cycle\_graph}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hascyc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hascyc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_combine}}{hash\_combine}}\label{hash_combine}

\texttt{hash\_combine} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_combine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_combine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_delete}}{hash\_delete}}\label{hash_delete}

\texttt{hash\_delete} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_delete $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_delete |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_eq}}{hash\_eq}}\label{hash_eq}

\texttt{hash\_eq} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_filter\_keys}}{hash\_filter\_keys}}\label{hash_filter_keys}

\texttt{hash\_filter\_keys} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_filter\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_filter\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_filter\_values}}{hash\_filter\_values}}\label{hash_filter_values}

\texttt{hash\_filter\_values} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_filter\_values $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_filter\_values |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_from\_list}}{hash\_from\_list}}\label{hash_from_list}

\texttt{hash\_from\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_from\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_from\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_from\_pairs}}{hash\_from\_pairs}}\label{hash_from_pairs}

\texttt{hash\_from\_pairs} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_from\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_from\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_insert}}{hash\_insert}}\label{hash_insert}

\texttt{hash\_insert} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_insert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_insert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_map\_values}}{hash\_map\_values}}\label{hash_map_values}

\texttt{hash\_map\_values} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_map\_values $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_map\_values |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_merge\_deep}}{hash\_merge\_deep}}\label{hash_merge_deep}

\texttt{hash\_merge\_deep} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_merge\_deep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_merge\_deep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_size}}{hash\_size}}\label{hash_size}

\texttt{hash\_size} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_to\_list}}{hash\_to\_list}}\label{hash_to_list}

\texttt{hash\_to\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_to\_list $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_update}}{hash\_update}}\label{hash_update}

\texttt{hash\_update} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hash\_zip}}{hash\_zip}}\label{hash_zip}

\texttt{hash\_zip} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hash\_zip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hash\_zip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hausdorff\_distance\_2d}}{hausdorff\_distance\_2d}}\label{hausdorff_distance_2d}

\texttt{hausdorff\_distance\_2d} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hausdorff\_distance\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hausdorff\_distance\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hausman\_test}}{hausman\_test}}\label{hausman_test}

\texttt{hausman\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hausman\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hausman\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{havdist}}{havdist}}\label{havdist}

\texttt{havdist} --- geometry (extended) builtin. Alias for
\texttt{haversine\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = havdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map havdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{haversine}}{haversine}}\label{haversine}

\texttt{haversine\_distance(\$lat1,\ \$lon1,\ \$lat2,\ \$lon2)} (alias
\texttt{haversine}) --- computes the great-circle distance between two
points on Earth given latitude/longitude in degrees. Returns distance in
kilometers.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# NYC to LA}
\NormalTok{p haversine(40.7128, {-}74.0060, 34.0522, {-}118.2437)}
\NormalTok{\# \textasciitilde{}3940 km}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{haversine\_dist}}{haversine\_dist}}\label{haversine_dist}

\texttt{haversine\_dist} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = haversine\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map haversine\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hawk\_dove\_payoff}}{hawk\_dove\_payoff}}\label{hawk_dove_payoff}

\texttt{hawk\_dove\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hawk\_dove\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hawk\_dove\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hawking\_area\_increase}}{hawking\_area\_increase}}\label{hawking_area_increase}

\texttt{hawking\_area\_increase} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hawking\_area\_increase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hawking\_area\_increase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hclust}}{hclust}}\label{hclust}

\texttt{hclust} --- hierarchical clustering (average linkage). Takes a
distance matrix. Returns merge list {[}{[}i,j,height{]},...{]}. Like
R\textquotesingle s hclust().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $merges = hclust(dist\_mat([[0,0],[1,0],[10,10]]))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{head\_finding\_collins}}{head\_finding\_collins}}\label{head_finding_collins}

\texttt{head\_finding\_collins} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = head\_finding\_collins $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map head\_finding\_collins |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{head\_lines}}{head\_lines}}\label{head_lines}

\texttt{head\_lines} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = head\_lines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map head\_lines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{head\_n}}{head\_n}}\label{head_n}

\texttt{head\_n} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = head\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map head\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{head\_str}}{head\_str}}\label{head_str}

\texttt{head\_str} --- string (batch 2) builtin. Alias for
\texttt{left\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = head\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map head\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heap\_sift\_down}}{heap\_sift\_down}}\label{heap_sift_down}

\texttt{heap\_sift\_down} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heap\_sift\_down $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heap\_sift\_down |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heat\_capacity\_q}}{heat\_capacity\_q}}\label{heat_capacity_q}

\texttt{heat\_capacity\_q} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heat\_capacity\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heat\_capacity\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heat\_flow\_radiogenic}}{heat\_flow\_radiogenic}}\label{heat_flow_radiogenic}

\texttt{heat\_flow\_radiogenic} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heat\_flow\_radiogenic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heat\_flow\_radiogenic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heat\_index}}{heat\_index}}\label{heat_index}

\texttt{heat\_index} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heat\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heat\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heat\_index\_celsius}}{heat\_index\_celsius}}\label{heat_index_celsius}

\texttt{heat\_index\_celsius} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heat\_index\_celsius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heat\_index\_celsius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hebrew\_leap\_year}}{hebrew\_leap\_year}}\label{hebrew_leap_year}

\texttt{hebrew\_leap\_year} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hebrew\_leap\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hebrew\_leap\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hebrew\_year\_length}}{hebrew\_year\_length}}\label{hebrew_year_length}

\texttt{hebrew\_year\_length} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hebrew\_year\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hebrew\_year\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heckman\_correction}}{heckman\_correction}}\label{heckman_correction}

\texttt{heckman\_correction} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heckman\_correction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heckman\_correction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heegaard\_genus\_lower}}{heegaard\_genus\_lower}}\label{heegaard_genus_lower}

\texttt{heegaard\_genus\_lower} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heegaard\_genus\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heegaard\_genus\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heisenberg\_min}}{heisenberg\_min}}\label{heisenberg_min}

\texttt{heisenberg\_min} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heisenberg\_min $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heisenberg\_min |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hellinger\_distance\_step}}{hellinger\_distance\_step}}\label{hellinger_distance_step}

\texttt{hellinger\_distance\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hellinger\_distance\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hellinger\_distance\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hellinger\_kernel}}{hellinger\_kernel}}\label{hellinger_kernel}

\texttt{hellinger\_kernel} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hellinger\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hellinger\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{helmholtz\_capacitance}}{helmholtz\_capacitance}}\label{helmholtz_capacitance}

\texttt{helmholtz\_capacitance} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = helmholtz\_capacitance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map helmholtz\_capacitance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{helmholtz\_decomp\_step}}{helmholtz\_decomp\_step}}\label{helmholtz_decomp_step}

\texttt{helmholtz\_decomp\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = helmholtz\_decomp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map helmholtz\_decomp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{henderson\_base}}{henderson\_base}}\label{henderson_base}

\texttt{henderson\_base} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = henderson\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map henderson\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{henderson\_buffer}}{henderson\_buffer}}\label{henderson_buffer}

\texttt{henderson\_buffer} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = henderson\_buffer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map henderson\_buffer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{henderson\_hasselbalch\_solve}}{henderson\_hasselbalch\_solve}}\label{henderson_hasselbalch_solve}

\texttt{henderson\_hasselbalch\_solve} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = henderson\_hasselbalch\_solve $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map henderson\_hasselbalch\_solve |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{henikoff\_weight}}{henikoff\_weight}}\label{henikoff_weight}

\texttt{henikoff\_weight} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = henikoff\_weight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map henikoff\_weight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{herd\_immunity\_threshold}}{herd\_immunity\_threshold}}\label{herd_immunity_threshold}

\texttt{herd\_immunity\_threshold} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = herd\_immunity\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map herd\_immunity\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heron}}{heron}}\label{heron}

\texttt{heron} --- geometry / physics builtin. Alias for
\texttt{heron\_area}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heron $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heron |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heron\_area}}{heron\_area}}\label{heron_area}

\texttt{heron\_area} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heron\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heron\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heston\_price\_simple}}{heston\_price\_simple}}\label{heston_price_simple}

\texttt{heston\_price\_simple} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heston\_price\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heston\_price\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heteroskedasticity\_test}}{heteroskedasticity\_test}}\label{heteroskedasticity_test}

\texttt{heteroskedasticity\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heteroskedasticity\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heteroskedasticity\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heterozygosity}}{heterozygosity}}\label{heterozygosity}

\texttt{heterozygosity} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heterozygosity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heterozygosity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heun\_euler\_step}}{heun\_euler\_step}}\label{heun_euler_step}

\texttt{heun\_euler\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heun\_euler\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heun\_euler\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heun\_method}}{heun\_method}}\label{heun_method}

\texttt{heun\_method} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heun\_method $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heun\_method |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{heun\_sde\_step}}{heun\_sde\_step}}\label{heun_sde_step}

\texttt{heun\_sde\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = heun\_sde\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map heun\_sde\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_lower}}{hex\_lower}}\label{hex_lower}

\texttt{hex\_lower} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hex\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hex\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_of}}{hex\_of}}\label{hex_of}

\texttt{hex\_of} --- base conversion builtin. Alias for
\texttt{to\_hex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hex\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hex\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_to\_bytes}}{hex\_to\_bytes}}\label{hex_to_bytes}

\texttt{hex\_to\_bytes} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hex\_to\_bytes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_to\_rgb}}{hex\_to\_rgb}}\label{hex_to_rgb}

\texttt{hex\_to\_rgb} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hex\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hex\_upper}}{hex\_upper}}\label{hex_upper}

\texttt{hex\_upper} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hex\_upper $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hex\_upper |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hget}}{hget}}\label{hget}

\texttt{hget} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hgetall}}{hgetall}}\label{hgetall}

\texttt{hgetall} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hgetall $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hgetall |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hhi\_concentration}}{hhi\_concentration}}\label{hhi_concentration}

\texttt{hhi\_concentration} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hhi\_concentration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hhi\_concentration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hicksian\_demand}}{hicksian\_demand}}\label{hicksian_demand}

\texttt{hicksian\_demand} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hicksian\_demand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hicksian\_demand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hidden}}{hidden}}\label{hidden}

\texttt{hidden} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hidden $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hidden |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{highpass\_filter}}{highpass\_filter}}\label{highpass_filter}

\texttt{highpass\_filter(\textbackslash{}@signal,\ \$cutoff)} (alias
\texttt{hpf}) --- applies a simple high-pass filter to remove
low-frequency components (DC offset, drift). Signal = original -
lowpass.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @with\_dc = map \{ 5 + sin(\_/10) \} 1:100}
\NormalTok{my $ac\_only = hpf(\textbackslash{}@with\_dc, 0.1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{highway\_hash}}{highway\_hash}}\label{highway_hash}

\texttt{highway\_hash} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = highway\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map highway\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hilbert\_envelope}}{hilbert\_envelope}}\label{hilbert_envelope}

\texttt{hilbert\_envelope} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hilbert\_envelope $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hilbert\_envelope |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hilbert\_signal}}{hilbert\_signal}}\label{hilbert_signal}

\texttt{hilbert\_signal} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hilbert\_signal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hilbert\_signal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hill\_equation}}{hill\_equation}}\label{hill_equation}

\texttt{hill\_equation} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hill\_equation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hill\_equation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hill\_radius}}{hill\_radius}}\label{hill_radius}

\texttt{hill\_radius} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hill\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hill\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hill\_sphere\_radius}}{hill\_sphere\_radius}}\label{hill_sphere_radius}

\texttt{hill\_sphere\_radius} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hill\_sphere\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hill\_sphere\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hill\_velocity}}{hill\_velocity}}\label{hill_velocity}

\texttt{hill\_velocity} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hill\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hill\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hincrby}}{hincrby}}\label{hincrby}

\texttt{hincrby} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hincrby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hincrby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hindley\_milner\_step}}{hindley\_milner\_step}}\label{hindley_milner_step}

\texttt{hindley\_milner\_step} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hindley\_milner\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hindley\_milner\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hindu\_lunisolar\_month}}{hindu\_lunisolar\_month}}\label{hindu_lunisolar_month}

\texttt{hindu\_lunisolar\_month} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hindu\_lunisolar\_month $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hindu\_lunisolar\_month |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hindu\_solar\_year}}{hindu\_solar\_year}}\label{hindu_solar_year}

\texttt{hindu\_solar\_year} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hindu\_solar\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hindu\_solar\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hinge\_loss}}{hinge\_loss}}\label{hinge_loss}

\texttt{hinge\_loss} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hinge\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hinge\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hirschberg\_lcs\_length}}{hirschberg\_lcs\_length}}\label{hirschberg_lcs_length}

\texttt{hirschberg\_lcs\_length} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hirschberg\_lcs\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hirschberg\_lcs\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hirzebruch\_signature}}{hirzebruch\_signature}}\label{hirzebruch_signature}

\texttt{hirzebruch\_signature} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hirzebruch\_signature $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hirzebruch\_signature |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hist}}{hist}}\label{hist}

\texttt{hist} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{histogram}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{histogram}}{histogram}}\label{histogram}

\texttt{histogram} --- matrix operations (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = histogram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map histogram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{histogram\_bin\_edges}}{histogram\_bin\_edges}}\label{histogram_bin_edges}

\texttt{histogram\_bin\_edges} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = histogram\_bin\_edges $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map histogram\_bin\_edges |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{histogram\_bins}}{histogram\_bins}}\label{histogram_bins}

\texttt{histogram\_bins} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = histogram\_bins $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map histogram\_bins |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hits\_authority}}{hits\_authority}}\label{hits_authority}

\texttt{hits\_authority} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hits\_authority $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hits\_authority |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hits\_hub}}{hits\_hub}}\label{hits_hub}

\texttt{hits\_hub} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hits\_hub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hits\_hub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hits\_simple}}{hits\_simple}}\label{hits_simple}

\texttt{hits\_simple} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hits\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hits\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hitting\_set\_greedy}}{hitting\_set\_greedy}}\label{hitting_set_greedy}

\texttt{hitting\_set\_greedy} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hitting\_set\_greedy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hitting\_set\_greedy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hk}}{hk}}\label{hk}

\texttt{hk} --- hash helpers builtin. Alias for \texttt{has\_key}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hkdf\_expand\_step}}{hkdf\_expand\_step}}\label{hkdf_expand_step}

\texttt{hkdf\_expand\_step} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hkdf\_expand\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hkdf\_expand\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hkeys}}{hkeys}}\label{hkeys}

\texttt{hkeys} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hkeys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hkeys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hlen}}{hlen}}\label{hlen}

\texttt{hlen} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hlen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hlen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hlookup}}{hlookup}}\label{hlookup}

\texttt{hlookup} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hlookup $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hlookup |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmac\_step\_xor}}{hmac\_step\_xor}}\label{hmac_step_xor}

\texttt{hmac\_step\_xor} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hmac\_step\_xor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hmac\_step\_xor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hmset}}{hmset}}\label{hmset}

\texttt{hmset} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hmset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hmset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hochschild\_zero}}{hochschild\_zero}}\label{hochschild_zero}

\texttt{hochschild\_zero} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hochschild\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hochschild\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hodge\_diamond\_value}}{hodge\_diamond\_value}}\label{hodge_diamond_value}

\texttt{hodge\_diamond\_value} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hodge\_diamond\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hodge\_diamond\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hodge\_inner\_product\_one}}{hodge\_inner\_product\_one}}\label{hodge_inner_product_one}

\texttt{hodge\_inner\_product\_one} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hodge\_inner\_product\_one $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hodge\_inner\_product\_one |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hodge\_polynomial\_eval}}{hodge\_polynomial\_eval}}\label{hodge_polynomial_eval}

\texttt{hodge\_polynomial\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hodge\_polynomial\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hodge\_polynomial\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hodge\_star\_one\_form}}{hodge\_star\_one\_form}}\label{hodge_star_one_form}

\texttt{hodge\_star\_one\_form} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hodge\_star\_one\_form $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hodge\_star\_one\_form |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hodges\_lehmann}}{hodges\_lehmann}}\label{hodges_lehmann}

\texttt{hodges\_lehmann} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hodges\_lehmann $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hodges\_lehmann |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hog\_features}}{hog\_features}}\label{hog_features}

\texttt{hog\_features} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hog\_features $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hog\_features |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hohmann\_dv1}}{hohmann\_dv1}}\label{hohmann_dv1}

\texttt{hohmann\_dv1} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hohmann\_dv1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hohmann\_dv1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hohmann\_dv2}}{hohmann\_dv2}}\label{hohmann_dv2}

\texttt{hohmann\_dv2} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hohmann\_dv2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hohmann\_dv2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hohmann\_total}}{hohmann\_total}}\label{hohmann_total}

\texttt{hohmann\_total} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hohmann\_total $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hohmann\_total |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{holling\_type1}}{holling\_type1}}\label{holling_type1}

\texttt{holling\_type1} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = holling\_type1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map holling\_type1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{holling\_type2}}{holling\_type2}}\label{holling_type2}

\texttt{holling\_type2} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = holling\_type2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map holling\_type2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{holling\_type3}}{holling\_type3}}\label{holling_type3}

\texttt{holling\_type3} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = holling\_type3 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map holling\_type3 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{holographic\_entanglement\_step}}{holographic\_entanglement\_step}}\label{holographic_entanglement_step}

\texttt{holographic\_entanglement\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = holographic\_entanglement\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map holographic\_entanglement\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{holt\_winters\_additive}}{holt\_winters\_additive}}\label{holt_winters_additive}

\texttt{holt\_winters\_additive} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = holt\_winters\_additive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map holt\_winters\_additive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{holt\_winters\_multiplicative}}{holt\_winters\_multiplicative}}\label{holt_winters_multiplicative}

\texttt{holt\_winters\_multiplicative} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = holt\_winters\_multiplicative $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map holt\_winters\_multiplicative |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{home\_dir}}{home\_dir}}\label{home_dir}

\texttt{home\_dir} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = home\_dir $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map home\_dir |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{homfly\_evaluation}}{homfly\_evaluation}}\label{homfly_evaluation}

\texttt{homfly\_evaluation} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = homfly\_evaluation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map homfly\_evaluation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{homology\_rank}}{homology\_rank}}\label{homology_rank}

\texttt{homology\_rank} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = homology\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map homology\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{homotopy\_group\_sphere\_pi}}{homotopy\_group\_sphere\_pi}}\label{homotopy_group_sphere_pi}

\texttt{homotopy\_group\_sphere\_pi} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = homotopy\_group\_sphere\_pi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map homotopy\_group\_sphere\_pi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hooke}}{hooke}}\label{hooke}

\texttt{hooke} --- physics formulas builtin. Alias for
\texttt{spring\_force}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hooke $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hooke |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hopcroft\_karp}}{hopcroft\_karp}}\label{hopcroft_karp}

\texttt{hopcroft\_karp} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hopcroft\_karp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hopcroft\_karp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hopcroft\_karp\_phase}}{hopcroft\_karp\_phase}}\label{hopcroft_karp_phase}

\texttt{hopcroft\_karp\_phase} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hopcroft\_karp\_phase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hopcroft\_karp\_phase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hopcroft\_karp\_step}}{hopcroft\_karp\_step}}\label{hopcroft_karp_step}

\texttt{hopcroft\_karp\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hopcroft\_karp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hopcroft\_karp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{horizon\_distance}}{horizon\_distance}}\label{horizon_distance}

\texttt{horizon\_distance} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = horizon\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map horizon\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{horn\_schunck\_step}}{horn\_schunck\_step}}\label{horn_schunck_step}

\texttt{horn\_schunck\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = horn\_schunck\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map horn\_schunck\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{horndeski\_step}}{horndeski\_step}}\label{horndeski_step}

\texttt{horndeski\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = horndeski\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map horndeski\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{horspool\_search}}{horspool\_search}}\label{horspool_search}

\texttt{horspool\_search} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = horspool\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map horspool\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hostname\_str}}{hostname\_str}}\label{hostname_str}

\texttt{hostname\_str} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hostname\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hostname\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hotelling\_location\_step}}{hotelling\_location\_step}}\label{hotelling_location_step}

\texttt{hotelling\_location\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hotelling\_location\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hotelling\_location\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hotelling\_price\_step}}{hotelling\_price\_step}}\label{hotelling_price_step}

\texttt{hotelling\_price\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hotelling\_price\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hotelling\_price\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hough\_accumulator\_step}}{hough\_accumulator\_step}}\label{hough_accumulator_step}

\texttt{hough\_accumulator\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hough\_accumulator\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hough\_accumulator\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hough\_circles}}{hough\_circles}}\label{hough_circles}

\texttt{hough\_circles} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hough\_circles $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hough\_circles |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hough\_lines}}{hough\_lines}}\label{hough_lines}

\texttt{hough\_lines} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hough\_lines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hough\_lines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hours\_to\_days}}{hours\_to\_days}}\label{hours_to_days}

\texttt{hours\_to\_days} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hours\_to\_days $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hours\_to\_minutes}}{hours\_to\_minutes}}\label{hours_to_minutes}

\texttt{hours\_to\_minutes} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hours\_to\_minutes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hours\_to\_seconds}}{hours\_to\_seconds}}\label{hours_to_seconds}

\texttt{hours\_to\_seconds} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hours\_to\_seconds $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{householder\_root}}{householder\_root}}\label{householder_root}

\texttt{householder\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = householder\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map householder\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hp\_to\_watts}}{hp\_to\_watts}}\label{hp_to_watts}

\texttt{hp\_to\_watts} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hp\_to\_watts $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hr}}{hr}}\label{hr}

\texttt{hr} --- data / network builtin. Alias for
\texttt{http\_request}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hset}}{hset}}\label{hset}

\texttt{hset} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hsl2rgb}}{hsl2rgb}}\label{hsl2rgb}

\texttt{hsl2rgb} --- color operations builtin. Alias for
\texttt{hsl\_to\_rgb}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hsl2rgb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hsl2rgb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hsl\_to\_rgb}}{hsl\_to\_rgb}}\label{hsl_to_rgb}

\texttt{hsl\_to\_rgb} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hsl\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hstore\_to\_array}}{hstore\_to\_array}}\label{hstore_to_array}

\texttt{hstore\_to\_array} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hstore\_to\_array $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hsv2rgb}}{hsv2rgb}}\label{hsv2rgb}

\texttt{hsv2rgb} --- color operations builtin. Alias for
\texttt{hsv\_to\_rgb}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hsv2rgb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hsv2rgb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hsv\_to\_rgb}}{hsv\_to\_rgb}}\label{hsv_to_rgb}

\texttt{hsv\_to\_rgb} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hsv\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{html\_decode}}{html\_decode}}\label{html_decode}

\texttt{html\_decode} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = html\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map html\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{html\_encode}}{html\_encode}}\label{html_encode}

\texttt{html\_encode} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = html\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map html\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{htmld}}{htmld}}\label{htmld}

\texttt{htmld} --- extended stdlib builtin. Alias for
\texttt{html\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = htmld $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map htmld |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{htmle}}{htmle}}\label{htmle}

\texttt{htmle} --- extended stdlib builtin. Alias for
\texttt{html\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = htmle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map htmle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hubble\_constant}}{hubble\_constant}}\label{hubble_constant}

\texttt{hubble\_constant} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hubble\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hubble\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hubble\_distance\_mpc}}{hubble\_distance\_mpc}}\label{hubble_distance_mpc}

\texttt{hubble\_distance\_mpc} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hubble\_distance\_mpc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hubble\_distance\_mpc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hubble\_distance\_si}}{hubble\_distance\_si}}\label{hubble_distance_si}

\texttt{hubble\_distance\_si} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hubble\_distance\_si $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hubble\_distance\_si |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hubble\_lcdm}}{hubble\_lcdm}}\label{hubble_lcdm}

\texttt{hubble\_lcdm} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hubble\_lcdm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hubble\_lcdm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hubble\_time}}{hubble\_time}}\label{hubble_time}

\texttt{hubble\_time} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hubble\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hubble\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{huber\_m\_estimator}}{huber\_m\_estimator}}\label{huber_m_estimator}

\texttt{huber\_m\_estimator} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = huber\_m\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map huber\_m\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{huffman\_balanced\_step}}{huffman\_balanced\_step}}\label{huffman_balanced_step}

\texttt{huffman\_balanced\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = huffman\_balanced\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map huffman\_balanced\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hull\_white\_drift}}{hull\_white\_drift}}\label{hull_white_drift}

\texttt{hull\_white\_drift} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hull\_white\_drift $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hull\_white\_drift |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{human\_bytes}}{human\_bytes}}\label{human_bytes}

\texttt{human\_bytes} --- file stat / path builtin. Alias for
\texttt{format\_bytes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = human\_bytes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map human\_bytes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{human\_duration}}{human\_duration}}\label{human_duration}

\texttt{human\_duration} --- file stat / path builtin. Alias for
\texttt{format\_duration}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = human\_duration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map human\_duration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{humidex}}{humidex}}\label{humidex}

\texttt{humidex} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = humidex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map humidex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hungarian\_method\_step}}{hungarian\_method\_step}}\label{hungarian_method_step}

\texttt{hungarian\_method\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hungarian\_method\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hungarian\_method\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hungarian\_step}}{hungarian\_step}}\label{hungarian_step}

\texttt{hungarian\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hungarian\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hungarian\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hurst\_exponent\_estimate}}{hurst\_exponent\_estimate}}\label{hurst_exponent_estimate}

\texttt{hurst\_exponent\_estimate} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hurst\_exponent\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hurst\_exponent\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hvals}}{hvals}}\label{hvals}

\texttt{hvals} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hvals $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hvals |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hw\_expected\_counts}}{hw\_expected\_counts}}\label{hw_expected_counts}

\texttt{hw\_expected\_counts} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hw\_expected\_counts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hw\_expected\_counts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hxd}}{hxd}}\label{hxd}

\texttt{hxd} --- crypto / encoding builtin. Alias for
\texttt{hex\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hxd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hxd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hxe}}{hxe}}\label{hxe}

\texttt{hxe} --- crypto / encoding builtin. Alias for
\texttt{hex\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hxe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hxe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hydrogen\_energy\_n}}{hydrogen\_energy\_n}}\label{hydrogen_energy_n}

\texttt{hydrogen\_energy\_n} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hydrogen\_energy\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hydrogen\_energy\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hyp}}{hyp}}\label{hyp}

\texttt{hyp} --- geometry / physics builtin. Alias for
\texttt{triangle\_hypotenuse}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hyp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hyp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hyp1f1}}{hyp1f1}}\label{hyp1f1}

\texttt{hyp1f1} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hyp1f1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hyp1f1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hyp2f1}}{hyp2f1}}\label{hyp2f1}

\texttt{hyp2f1} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hyp2f1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hyp2f1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hyper0f1}}{hyper0f1}}\label{hyper0f1}

\texttt{hyper0f1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hyper0f1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hyper0f1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hyper1f1}}{hyper1f1}}\label{hyper1f1}

\texttt{hyper1f1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hyper1f1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hyper1f1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hyper2f1}}{hyper2f1}}\label{hyper2f1}

\texttt{hyper2f1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hyper2f1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hyper2f1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hypot}}{hypot}}\label{hypot}

\texttt{hypot} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hypot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map hypot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{hz\_to\_midi}}{hz\_to\_midi}}\label{hz_to_midi}

\texttt{hz\_to\_midi} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = hz\_to\_midi $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{i64\_max}}{i64\_max}}\label{i64_max}

\texttt{i64\_max} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = i64\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map i64\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{i64\_min}}{i64\_min}}\label{i64_min}

\texttt{i64\_min} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = i64\_min $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map i64\_min |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iban\_check}}{iban\_check}}\label{iban_check}

\texttt{iban\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iban\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iban\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ibnr\_estimate}}{ibnr\_estimate}}\label{ibnr_estimate}

\texttt{ibnr\_estimate} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ibnr\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ibnr\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ical}}{ical}}\label{ical}

\texttt{ical} --- haskell list functions builtin. Alias for
\texttt{intercalate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ical $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ical |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ice\_age\_milankovitch}}{ice\_age\_milankovitch}}\label{ice_age_milankovitch}

\texttt{ice\_age\_milankovitch} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ice\_age\_milankovitch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ice\_age\_milankovitch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{icosahedral\_number}}{icosahedral\_number}}\label{icosahedral_number}

\texttt{icosahedral\_number} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = icosahedral\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map icosahedral\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{id}}{id}}\label{id}

\texttt{id} --- trivial numeric / predicate builtins builtin. Alias for
\texttt{identity}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = id $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map id |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ida\_star}}{ida\_star}}\label{ida_star}

\texttt{ida\_star} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ida\_star $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ida\_star |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idamax}}{idamax}}\label{idamax}

\texttt{idamax} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = idamax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map idamax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idct}}{idct}}\label{idct}

\texttt{idct} computes the inverse DCT (Type-III). Reconstructs a signal
from DCT coefficients.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @signal = @\{idct(dct([1,2,3,4]))\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ideal\_gas}}{ideal\_gas}}\label{ideal_gas}

\texttt{ideal\_gas} (alias \texttt{pv\_nrt}) solves PV=nRT for the
unknown (pass 0 for the value to solve). Args: P, V, n, T.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pv\_nrt(0, 0.0224, 1, 273.15)  \# pressure at STP}
\NormalTok{p pv\_nrt(101325, 0, 1, 273.15)   \# volume at STP}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ideal\_gas\_n}}{ideal\_gas\_n}}\label{ideal_gas_n}

\texttt{ideal\_gas\_n} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ideal\_gas\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ideal\_gas\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ideal\_gas\_volume}}{ideal\_gas\_volume}}\label{ideal_gas_volume}

\texttt{ideal\_gas\_volume} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ideal\_gas\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ideal\_gas\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{identity}}{identity}}\label{identity}

\texttt{identity} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = identity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map identity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{identity\_matrix}}{identity\_matrix}}\label{identity_matrix}

\texttt{identity\_matrix} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = identity\_matrix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map identity\_matrix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{identity\_permutation}}{identity\_permutation}}\label{identity_permutation}

\texttt{identity\_permutation} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = identity\_permutation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map identity\_permutation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idft}}{idft}}\label{idft}

\texttt{idft(\textbackslash{}@spectrum)} --- computes the Inverse
Discrete Fourier Transform. Takes arrayref of {[}re, im{]} pairs and
returns the time-domain signal.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $spectrum = dft(\textbackslash{}@signal)}
\NormalTok{my $reconstructed = idft($spectrum)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idn\_normalize}}{idn\_normalize}}\label{idn_normalize}

\texttt{idn\_normalize} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = idn\_normalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map idn\_normalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idn\_to\_ascii}}{idn\_to\_ascii}}\label{idn_to_ascii}

\texttt{idn\_to\_ascii} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = idn\_to\_ascii $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idn\_to\_unicode}}{idn\_to\_unicode}}\label{idn_to_unicode}

\texttt{idn\_to\_unicode} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = idn\_to\_unicode $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idt}}{idt}}\label{idt}

\texttt{idt} --- extended stdlib builtin. Alias for \texttt{indent}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = idt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map idt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{idxb}}{idxb}}\label{idxb}

\texttt{idxb} --- go/general functional utilities builtin. Alias for
\texttt{index\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = idxb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map idxb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{if\_else}}{if\_else}}\label{if_else}

\texttt{if\_else} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = if\_else $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map if\_else |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{if\_match\_check}}{if\_match\_check}}\label{if_match_check}

\texttt{if\_match\_check} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = if\_match\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map if\_match\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{if\_none\_match\_check}}{if\_none\_match\_check}}\label{if_none_match_check}

\texttt{if\_none\_match\_check} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = if\_none\_match\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map if\_none\_match\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ifr\_infection\_fatality}}{ifr\_infection\_fatality}}\label{ifr_infection_fatality}

\texttt{ifr\_infection\_fatality} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ifr\_infection\_fatality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ifr\_infection\_fatality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{igneous\_qapf}}{igneous\_qapf}}\label{igneous_qapf}

\texttt{igneous\_qapf} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = igneous\_qapf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map igneous\_qapf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ilerp}}{ilerp}}\label{ilerp}

\texttt{ilerp} --- extended stdlib builtin. Alias for
\texttt{inv\_lerp}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ilerp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ilerp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_blur\_box}}{image\_blur\_box}}\label{image_blur_box}

\texttt{image\_blur\_box} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_blur\_box $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_blur\_box |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_blur\_gaussian}}{image\_blur\_gaussian}}\label{image_blur_gaussian}

\texttt{image\_blur\_gaussian} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_blur\_gaussian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_blur\_gaussian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_brightness}}{image\_brightness}}\label{image_brightness}

\texttt{image\_brightness} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_brightness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_brightness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_clahe}}{image\_clahe}}\label{image_clahe}

\texttt{image\_clahe} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_clahe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_clahe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_contrast}}{image\_contrast}}\label{image_contrast}

\texttt{image\_contrast} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_contrast $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_contrast |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_dilate}}{image\_dilate}}\label{image_dilate}

\texttt{image\_dilate} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_dilate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_dilate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_edge\_canny}}{image\_edge\_canny}}\label{image_edge_canny}

\texttt{image\_edge\_canny} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_edge\_canny $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_edge\_canny |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_edge\_laplacian}}{image\_edge\_laplacian}}\label{image_edge_laplacian}

\texttt{image\_edge\_laplacian} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_edge\_laplacian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_edge\_laplacian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_edge\_sobel}}{image\_edge\_sobel}}\label{image_edge_sobel}

\texttt{image\_edge\_sobel} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_edge\_sobel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_edge\_sobel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_emboss}}{image\_emboss}}\label{image_emboss}

\texttt{image\_emboss} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_emboss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_emboss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_equalize}}{image\_equalize}}\label{image_equalize}

\texttt{image\_equalize} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_equalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_equalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_erode}}{image\_erode}}\label{image_erode}

\texttt{image\_erode} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_erode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_erode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_flip\_h}}{image\_flip\_h}}\label{image_flip_h}

\texttt{image\_flip\_h} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_flip\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_flip\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_flip\_v}}{image\_flip\_v}}\label{image_flip_v}

\texttt{image\_flip\_v} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_flip\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_flip\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_gamma}}{image\_gamma}}\label{image_gamma}

\texttt{image\_gamma} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_gamma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_gamma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_grayscale}}{image\_grayscale}}\label{image_grayscale}

\texttt{image\_grayscale} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_grayscale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_grayscale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_histogram}}{image\_histogram}}\label{image_histogram}

\texttt{image\_histogram} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_histogram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_histogram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_invert}}{image\_invert}}\label{image_invert}

\texttt{image\_invert} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_invert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_invert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_morphology\_close}}{image\_morphology\_close}}\label{image_morphology_close}

\texttt{image\_morphology\_close} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_morphology\_close $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_morphology\_close |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_morphology\_open}}{image\_morphology\_open}}\label{image_morphology_open}

\texttt{image\_morphology\_open} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_morphology\_open $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_morphology\_open |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_motion\_blur}}{image\_motion\_blur}}\label{image_motion_blur}

\texttt{image\_motion\_blur} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_motion\_blur $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_motion\_blur |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_posterize}}{image\_posterize}}\label{image_posterize}

\texttt{image\_posterize} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_posterize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_posterize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_resize}}{image\_resize}}\label{image_resize}

\texttt{image\_resize} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_resize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_resize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_rotate}}{image\_rotate}}\label{image_rotate}

\texttt{image\_rotate} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_rotate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_rotate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_sepia}}{image\_sepia}}\label{image_sepia}

\texttt{image\_sepia} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_sepia $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_sepia |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_sharpen}}{image\_sharpen}}\label{image_sharpen}

\texttt{image\_sharpen} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_sharpen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_sharpen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_solarize}}{image\_solarize}}\label{image_solarize}

\texttt{image\_solarize} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_solarize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_solarize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{image\_threshold}}{image\_threshold}}\label{image_threshold}

\texttt{image\_threshold} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = image\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map image\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imei\_check}}{imei\_check}}\label{imei_check}

\texttt{imei\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imei\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imei\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imex\_euler\_step}}{imex\_euler\_step}}\label{imex_euler_step}

\texttt{imex\_euler\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imex\_euler\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imex\_euler\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imex\_theta\_split}}{imex\_theta\_split}}\label{imex_theta_split}

\texttt{imex\_theta\_split} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imex\_theta\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imex\_theta\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{impedance\_rlc}}{impedance\_rlc}}\label{impedance_rlc}

\texttt{impedance\_rlc} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = impedance\_rlc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map impedance\_rlc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{impl}}{impl}}\label{impl}

\texttt{impl} declares which traits a class implements.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{trait Printable \{ fn to\_str \}}
\NormalTok{class Item impl Printable \{}
\NormalTok{    name: Str}
\NormalTok{    fn to\_str \{ $self{-}\textgreater{}name \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Multiple traits: \texttt{class\ X\ impl\ A,\ B,\ C\ \{\ \}}

\section{\texorpdfstring{\texttt{implicit\_euler}}{implicit\_euler}}\label{implicit_euler}

\texttt{implicit\_euler} --- batch 19 builtin. Alias for
\texttt{backward\_euler}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = implicit\_euler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map implicit\_euler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{impulse}}{impulse}}\label{impulse}

\texttt{impulse(\$force,\ \$time)} --- compute impulse J = F×t (N⋅s).
Change in momentum.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p impulse(100, 0.5)   \# 50 N⋅s}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{impulse\_response\_n}}{impulse\_response\_n}}\label{impulse_response_n}

\texttt{impulse\_response\_n} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = impulse\_response\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map impulse\_response\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{impulse\_response\_step}}{impulse\_response\_step}}\label{impulse_response_step}

\texttt{impulse\_response\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = impulse\_response\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map impulse\_response\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imputation\_efficient\_check}}{imputation\_efficient\_check}}\label{imputation_efficient_check}

\texttt{imputation\_efficient\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imputation\_efficient\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imputation\_efficient\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imputation\_individual\_rational}}{imputation\_individual\_rational}}\label{imputation_individual_rational}

\texttt{imputation\_individual\_rational} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imputation\_individual\_rational $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imputation\_individual\_rational |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imu\_madgwick\_step}}{imu\_madgwick\_step}}\label{imu_madgwick_step}

\texttt{imu\_madgwick\_step} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imu\_madgwick\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imu\_madgwick\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{imu\_mahony\_step}}{imu\_mahony\_step}}\label{imu_mahony_step}

\texttt{imu\_mahony\_step} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = imu\_mahony\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map imu\_mahony\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{in\_degree\_directed}}{in\_degree\_directed}}\label{in_degree_directed}

\texttt{in\_degree\_directed} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = in\_degree\_directed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map in\_degree\_directed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{in\_range}}{in\_range}}\label{in_range}

\texttt{in\_range} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = in\_range $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map in\_range |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inc}}{inc}}\label{inc}

\texttt{inc} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inc\_each}}{inc\_each}}\label{inc_each}

\texttt{inc\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inc\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inc\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{incentive\_compatibility\_check}}{incentive\_compatibility\_check}}\label{incentive_compatibility_check}

\texttt{incentive\_compatibility\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = incentive\_compatibility\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map incentive\_compatibility\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inches\_to\_cm}}{inches\_to\_cm}}\label{inches_to_cm}

\texttt{inches\_to\_cm} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inches\_to\_cm $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{incidence\_algebra\_dim}}{incidence\_algebra\_dim}}\label{incidence_algebra_dim}

\texttt{incidence\_algebra\_dim} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = incidence\_algebra\_dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map incidence\_algebra\_dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{includes\_val}}{includes\_val}}\label{includes_val}

\texttt{includes\_val} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = includes\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map includes\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{income\_elasticity}}{income\_elasticity}}\label{income_elasticity}

\texttt{income\_elasticity} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = income\_elasticity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map income\_elasticity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{incr}}{incr}}\label{incr}

\texttt{incr} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = incr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map incr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{incrby}}{incrby}}\label{incrby}

\texttt{incrby} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = incrby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map incrby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{incv}}{incv}}\label{incv}

\texttt{incv} --- javascript array/object methods builtin. Alias for
\texttt{includes\_val}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = incv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map incv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indenergy}}{indenergy}}\label{indenergy}

\texttt{indenergy} --- physics formulas builtin. Alias for
\texttt{inductor\_energy}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indenergy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indenergy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indent}}{indent}}\label{indent}

\texttt{indent} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indent\_text}}{indent\_text}}\label{indent_text}

\texttt{indent\_text} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indent\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indent\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{independence\_number\_upper}}{independence\_number\_upper}}\label{independence_number_upper}

\texttt{independence\_number\_upper} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = independence\_number\_upper $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map independence\_number\_upper |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_by}}{index\_by}}\label{index_by}

\texttt{index\_by} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_calculus\_naive}}{index\_calculus\_naive}}\label{index_calculus_naive}

\texttt{index\_calculus\_naive} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_calculus\_naive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_calculus\_naive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_from\_speed}}{index\_from\_speed}}\label{index_from_speed}

\texttt{index\_from\_speed} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_from\_speed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_from\_speed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_match}}{index\_match}}\label{index_match}

\texttt{index\_match} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_of}}{index\_of}}\label{index_of}

\texttt{index\_of} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_of\_coincidence}}{index\_of\_coincidence}}\label{index_of_coincidence}

\texttt{index\_of\_coincidence} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_of\_coincidence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_of\_coincidence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{index\_of\_elem}}{index\_of\_elem}}\label{index_of_elem}

\texttt{index\_of\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = index\_of\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map index\_of\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indexes\_of}}{indexes\_of}}\label{indexes_of}

\texttt{indexes\_of} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indexes\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indexes\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indian\_monsoon\_index}}{indian\_monsoon\_index}}\label{indian_monsoon_index}

\texttt{indian\_monsoon\_index} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indian\_monsoon\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indian\_monsoon\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indirect}}{indirect}}\label{indirect}

\texttt{indirect} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indirect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indirect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indirect\_age\_adjusted}}{indirect\_age\_adjusted}}\label{indirect_age_adjusted}

\texttt{indirect\_age\_adjusted} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indirect\_age\_adjusted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indirect\_age\_adjusted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indirect\_utility}}{indirect\_utility}}\label{indirect_utility}

\texttt{indirect\_utility} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indirect\_utility $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indirect\_utility |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{indivisible\_envy\_free\_check}}{indivisible\_envy\_free\_check}}\label{indivisible_envy_free_check}

\texttt{indivisible\_envy\_free\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = indivisible\_envy\_free\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map indivisible\_envy\_free\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inductance\_parallel}}{inductance\_parallel}}\label{inductance_parallel}

\texttt{inductance\_parallel} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inductance\_parallel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inductance\_parallel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inductance\_series}}{inductance\_series}}\label{inductance_series}

\texttt{inductance\_series} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inductance\_series $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inductance\_series |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inductor\_energy}}{inductor\_energy}}\label{inductor_energy}

\texttt{inductor\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inductor\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inductor\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{infinite\_well\_energy}}{infinite\_well\_energy}}\label{infinite_well_energy}

\texttt{infinite\_well\_energy} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = infinite\_well\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map infinite\_well\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{information\_bottleneck\_step}}{information\_bottleneck\_step}}\label{information_bottleneck_step}

\texttt{information\_bottleneck\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = information\_bottleneck\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map information\_bottleneck\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{information\_gain}}{information\_gain}}\label{information_gain}

\texttt{information\_gain} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = information\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map information\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{information\_ratio}}{information\_ratio}}\label{information_ratio}

\texttt{information\_ratio} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = information\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map information\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{init\_list}}{init\_list}}\label{init_list}

\texttt{init\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = init\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map init\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{initial\_bearing}}{initial\_bearing}}\label{initial_bearing}

\texttt{initial\_bearing} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = initial\_bearing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map initial\_bearing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{initials}}{initials}}\label{initials}

\texttt{initials} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = initials $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map initials |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inits}}{inits}}\label{inits}

\texttt{inits} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inits\_str}}{inits\_str}}\label{inits_str}

\texttt{inits\_str} --- string processing (uncategorized batch) builtin.
Alias for \texttt{initials}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inits\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inits\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inject}}{inject}}\label{inject}

\texttt{inject} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inject $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inject |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inrng}}{inrng}}\label{inrng}

\texttt{inrng} --- extended stdlib builtin. Alias for
\texttt{in\_range}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inrng $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inrng |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{insa}}{insa}}\label{insa}

\texttt{insa} --- go/general functional utilities builtin. Alias for
\texttt{insert\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = insa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map insa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{insert\_at}}{insert\_at}}\label{insert_at}

\texttt{insert\_at} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = insert\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map insert\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{insert\_at\_idx}}{insert\_at\_idx}}\label{insert_at_idx}

\texttt{insert\_at\_idx} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = insert\_at\_idx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map insert\_at\_idx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{insert\_sorted}}{insert\_sorted}}\label{insert_sorted}

\texttt{insert\_sorted} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = insert\_sorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map insert\_sorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{insert\_str}}{insert\_str}}\label{insert_str}

\texttt{insert\_str} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = insert\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map insert\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{insp}}{insp}}\label{insp}

\texttt{insp} --- rust iterator methods builtin. Alias for
\texttt{inspect}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = insp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map insp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inspect}}{inspect}}\label{inspect}

\texttt{inspect} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inspect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inspect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inssrt}}{inssrt}}\label{inssrt}

\texttt{inssrt} --- additional missing stdlib functions builtin. Alias
for \texttt{insert\_sorted}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inssrt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inssrt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{int\_bits}}{int\_bits}}\label{int_bits}

\texttt{int\_bits} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = int\_bits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map int\_bits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{int\_to\_ipv4}}{int\_to\_ipv4}}\label{int_to_ipv4}

\texttt{int\_to\_ipv4} --- network / validation builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = int\_to\_ipv4 $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{int\_to\_roman}}{int\_to\_roman}}\label{int_to_roman}

\texttt{int\_to\_roman} --- roman numerals builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = int\_to\_roman $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{integral\_length\_scale}}{integral\_length\_scale}}\label{integral_length_scale}

\texttt{integral\_length\_scale} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = integral\_length\_scale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map integral\_length\_scale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intercalate}}{intercalate}}\label{intercalate}

\texttt{intercalate} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intercalate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intercalate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{interleave\_lists}}{interleave\_lists}}\label{interleave_lists}

\texttt{interleave\_lists} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = interleave\_lists $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map interleave\_lists |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{internal\_rate\_of\_return}}{internal\_rate\_of\_return}}\label{internal_rate_of_return}

\texttt{internal\_rate\_of\_return} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = internal\_rate\_of\_return $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map internal\_rate\_of\_return |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{interp1d}}{interp1d}}\label{interp1d}

\texttt{interp1d} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = interp1d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map interp1d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{interpose}}{interpose}}\label{interpose}

\texttt{interpose} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = interpose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map interpose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intersect\_list}}{intersect\_list}}\label{intersect_list}

\texttt{intersect\_list} --- additional missing stdlib functions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intersect\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intersect\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intersperse}}{intersperse}}\label{intersperse}

\texttt{intersperse} --- collection helpers (trivial) builtin. Alias for
\texttt{riffle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intersperse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intersperse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intersperse\_char}}{intersperse\_char}}\label{intersperse_char}

\texttt{intersperse\_char} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intersperse\_char $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intersperse\_char |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intersperse\_val}}{intersperse\_val}}\label{intersperse_val}

\texttt{intersperse\_val} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intersperse\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intersperse\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intersperse\_with}}{intersperse\_with}}\label{intersperse_with}

\texttt{intersperse\_with} --- additional missing stdlib functions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intersperse\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intersperse\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{interval\_quality\_size}}{interval\_quality\_size}}\label{interval_quality_size}

\texttt{interval\_quality\_size} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = interval\_quality\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map interval\_quality\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{interval\_semitones}}{interval\_semitones}}\label{interval_semitones}

\texttt{interval\_semitones} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = interval\_semitones $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map interval\_semitones |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intl}}{intl}}\label{intl}

\texttt{intl} --- additional missing stdlib functions builtin. Alias for
\texttt{intersect\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{into}}{into}}\label{into}

\texttt{into} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = into $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map into |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intrate}}{intrate}}\label{intrate}

\texttt{intrate} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intrate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intrate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intrinsic\_growth\_rate}}{intrinsic\_growth\_rate}}\label{intrinsic_growth_rate}

\texttt{intrinsic\_growth\_rate} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intrinsic\_growth\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intrinsic\_growth\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{intrinsic\_principal\_curv}}{intrinsic\_principal\_curv}}\label{intrinsic_principal_curv}

\texttt{intrinsic\_principal\_curv} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = intrinsic\_principal\_curv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map intrinsic\_principal\_curv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inv\_lerp}}{inv\_lerp}}\label{inv_lerp}

\texttt{inv\_lerp} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inv\_lerp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inv\_lerp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse}}{inverse}}\label{inverse}

\texttt{inverse} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_chi2\_pdf}}{inverse\_chi2\_pdf}}\label{inverse_chi2_pdf}

\texttt{inverse\_chi2\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_chi2\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_chi2\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_kinematics\_2link}}{inverse\_kinematics\_2link}}\label{inverse_kinematics_2link}

\texttt{inverse\_kinematics\_2link} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_kinematics\_2link $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_kinematics\_2link |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_lerp}}{inverse\_lerp}}\label{inverse_lerp}

\texttt{inverse\_lerp} --- math formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_lerp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_lerp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_qft}}{inverse\_qft}}\label{inverse_qft}

\texttt{inverse\_qft} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_qft $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_qft |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_quad\_interp}}{inverse\_quad\_interp}}\label{inverse_quad_interp}

\texttt{inverse\_quad\_interp} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_quad\_interp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_quad\_interp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_simpson}}{inverse\_simpson}}\label{inverse_simpson}

\texttt{inverse\_simpson} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_simpson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_simpson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{inverse\_weibull\_pdf}}{inverse\_weibull\_pdf}}\label{inverse_weibull_pdf}

\texttt{inverse\_weibull\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = inverse\_weibull\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map inverse\_weibull\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{invert}}{invert}}\label{invert}

\texttt{invert} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = invert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map invert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{invert\_perm}}{invert\_perm}}\label{invert_perm}

\texttt{invert\_perm} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = invert\_perm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map invert\_perm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ioctl}}{ioctl}}\label{ioctl}

\texttt{ioctl} --- ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ioctl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ioctl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ionic\_conductivity\_arrhenius}}{ionic\_conductivity\_arrhenius}}\label{ionic_conductivity_arrhenius}

\texttt{ionic\_conductivity\_arrhenius} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ionic\_conductivity\_arrhenius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ionic\_conductivity\_arrhenius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ionic\_liquid\_viscosity\_step}}{ionic\_liquid\_viscosity\_step}}\label{ionic_liquid_viscosity_step}

\texttt{ionic\_liquid\_viscosity\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ionic\_liquid\_viscosity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ionic\_liquid\_viscosity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ionic\_strength}}{ionic\_strength}}\label{ionic_strength}

\texttt{ionic\_strength} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ionic\_strength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ionic\_strength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iota\_n}}{iota\_n}}\label{iota_n}

\texttt{iota\_n} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iota\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iota\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iou\_2d\_axis\_aligned}}{iou\_2d\_axis\_aligned}}\label{iou_2d_axis_aligned}

\texttt{iou\_2d\_axis\_aligned} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iou\_2d\_axis\_aligned $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iou\_2d\_axis\_aligned |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ipmt}}{ipmt}}\label{ipmt}

\texttt{ipmt} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ipmt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ipmt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ipos}}{ipos}}\label{ipos}

\texttt{ipos} --- go/general functional utilities builtin. Alias for
\texttt{interpose}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ipos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ipos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ipv4\_to\_int}}{ipv4\_to\_int}}\label{ipv4_to_int}

\texttt{ipv4\_to\_int} --- network / validation builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ipv4\_to\_int $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ipv\_potential\_vorticity}}{ipv\_potential\_vorticity}}\label{ipv_potential_vorticity}

\texttt{ipv\_potential\_vorticity} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ipv\_potential\_vorticity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ipv\_potential\_vorticity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iqr}}{iqr}}\label{iqr}

\texttt{iqr} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iqr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iqr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{irr}}{irr}}\label{irr}

\texttt{irr(@cashflows)} --- computes the Internal Rate of Return for a
series of cash flows. First value is typically negative (initial
investment). Uses Newton-Raphson iteration.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @cf = ({-}1000, 300, 420, 680)}
\NormalTok{p irr(@cf)   \# \textasciitilde{}0.166 (16.6\%)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_7\_smooth}}{is\_7\_smooth}}\label{is_7_smooth}

\texttt{is\_7\_smooth} --- batch 10 builtin. Alias for
\texttt{seven\_smooth\_q}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_7\_smooth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_7\_smooth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_abundant}}{is\_abundant}}\label{is_abundant}

\texttt{is\_abundant} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_abundant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_abundant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_alnum}}{is\_alnum}}\label{is_alnum}

\texttt{is\_alnum} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_alnum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_alnum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_alpha}}{is\_alpha}}\label{is_alpha}

\texttt{is\_alpha} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_anagram}}{is\_anagram}}\label{is_anagram}

\texttt{is\_anagram} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_anagram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_anagram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_anagram\_q}}{is\_anagram\_q}}\label{is_anagram_q}

\texttt{is\_anagram\_q} --- batch 11 builtin. Alias for
\texttt{anagram\_q}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_anagram\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_anagram\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_armstrong}}{is\_armstrong}}\label{is_armstrong}

\texttt{is\_armstrong} --- batch 11 builtin. Alias for
\texttt{armstrong\_q}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_armstrong $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_armstrong |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_array}}{is\_array}}\label{is_array}

\texttt{is\_array} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_array $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_array |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_arrayref}}{is\_arrayref}}\label{is_arrayref}

\texttt{is\_arrayref} --- trivial type predicates builtin. Alias for
\texttt{is\_array}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_arrayref $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_arrayref |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_asc}}{is\_asc}}\label{is_asc}

\texttt{is\_asc} --- predicates (batch 2) builtin. Alias for
\texttt{is\_sorted}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_asc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_asc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_ascii}}{is\_ascii}}\label{is_ascii}

\texttt{is\_ascii} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_ascii $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_ascii |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_b\_smooth}}{is\_b\_smooth}}\label{is_b_smooth}

\texttt{is\_b\_smooth} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_b\_smooth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_b\_smooth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_balanced\_parens}}{is\_balanced\_parens}}\label{is_balanced_parens}

\texttt{is\_balanced\_parens} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_balanced\_parens $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_balanced\_parens |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_base64}}{is\_base64}}\label{is_base64}

\texttt{is\_base64} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_base64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_base64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_between}}{is\_between}}\label{is_between}

\texttt{is\_between} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_binary\_str}}{is\_binary\_str}}\label{is_binary_str}

\texttt{is\_binary\_str} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_binary\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_binary\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_bipartite\_graph}}{is\_bipartite\_graph}}\label{is_bipartite_graph}

\texttt{is\_bipartite\_graph} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_bipartite\_graph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_bipartite\_graph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_blank}}{is\_blank}}\label{is_blank}

\texttt{is\_blank} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_blank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_blank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_blank\_or\_nil}}{is\_blank\_or\_nil}}\label{is_blank_or_nil}

\texttt{is\_blank\_or\_nil} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_blank\_or\_nil $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_blank\_or\_nil |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_callable}}{is\_callable}}\label{is_callable}

\texttt{is\_callable} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_callable $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_callable |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_carmichael}}{is\_carmichael}}\label{is_carmichael}

\texttt{is\_carmichael} --- batch 10 builtin. Alias for
\texttt{carmichael\_q}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_carmichael $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_carmichael |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_code}}{is\_code}}\label{is_code}

\texttt{is\_code} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_coderef}}{is\_coderef}}\label{is_coderef}

\texttt{is\_coderef} --- trivial type predicates builtin. Alias for
\texttt{is\_code}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_coderef $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_coderef |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_connected}}{is\_connected}}\label{is_connected}

\texttt{is\_connected} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_connected $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_connected |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_consonant}}{is\_consonant}}\label{is_consonant}

\texttt{is\_consonant} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_consonant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_consonant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_control}}{is\_control}}\label{is_control}

\texttt{is\_control} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_control $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_control |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_coprime}}{is\_coprime}}\label{is_coprime}

\texttt{is\_coprime} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_coprime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_coprime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_credit\_card}}{is\_credit\_card}}\label{is_credit_card}

\texttt{is\_credit\_card} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_credit\_card $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_credit\_card |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_def}}{is\_def}}\label{is_def}

\texttt{is\_def} --- trivial type predicates builtin. Alias for
\texttt{is\_defined}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_def $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_def |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_deficient}}{is\_deficient}}\label{is_deficient}

\texttt{is\_deficient} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_deficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_deficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_defined}}{is\_defined}}\label{is_defined}

\texttt{is\_defined} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_defined $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_defined |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_desc}}{is\_desc}}\label{is_desc}

\texttt{is\_desc} --- predicates (batch 2) builtin. Alias for
\texttt{is\_sorted\_desc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_desc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_desc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_digit}}{is\_digit}}\label{is_digit}

\texttt{is\_digit} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_digit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_digit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_divisible\_by}}{is\_divisible\_by}}\label{is_divisible_by}

\texttt{is\_divisible\_by} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_divisible\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_divisible\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_email}}{is\_email}}\label{is_email}

\texttt{is\_email} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_email $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_email |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_empty}}{is\_empty}}\label{is_empty}

\texttt{is\_empty} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_empty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_empty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_empty\_arr}}{is\_empty\_arr}}\label{is_empty_arr}

\texttt{is\_empty\_arr} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_empty\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_empty\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_empty\_hash}}{is\_empty\_hash}}\label{is_empty_hash}

\texttt{is\_empty\_hash} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_empty\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_empty\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_even}}{is\_even}}\label{is_even}

\texttt{is\_even} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_even $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_even |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_even\_num}}{is\_even\_num}}\label{is_even_num}

\texttt{is\_even\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_even\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_even\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_executable}}{is\_executable}}\label{is_executable}

\texttt{is\_executable} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_executable $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_executable |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_falsy}}{is\_falsy}}\label{is_falsy}

\texttt{is\_falsy} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_falsy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_falsy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_fibonacci}}{is\_fibonacci}}\label{is_fibonacci}

\texttt{is\_fibonacci} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_fibonacci $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_fibonacci |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_finite}}{is\_finite}}\label{is_finite}

\texttt{is\_finite} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_finite $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_finite |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_float}}{is\_float}}\label{is_float}

\texttt{is\_float} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_float $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_float |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_harshad}}{is\_harshad}}\label{is_harshad}

\texttt{is\_harshad} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_harshad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_harshad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_hash}}{is\_hash}}\label{is_hash}

\texttt{is\_hash} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_hashref}}{is\_hashref}}\label{is_hashref}

\texttt{is\_hashref} --- trivial type predicates builtin. Alias for
\texttt{is\_hash}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_hashref $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_hashref |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_heterogram}}{is\_heterogram}}\label{is_heterogram}

\texttt{is\_heterogram} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_heterogram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_heterogram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_hex\_color}}{is\_hex\_color}}\label{is_hex_color}

\texttt{is\_hex\_color} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_hex\_color $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_hex\_color |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_hex\_str}}{is\_hex\_str}}\label{is_hex_str}

\texttt{is\_hex\_str} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_hex\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_hex\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_hostname\_valid}}{is\_hostname\_valid}}\label{is_hostname_valid}

\texttt{is\_hostname\_valid} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_hostname\_valid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_hostname\_valid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_iban}}{is\_iban}}\label{is_iban}

\texttt{is\_iban} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_iban $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_iban |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_in\_range}}{is\_in\_range}}\label{is_in_range}

\texttt{is\_in\_range} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_in\_range $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_in\_range |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_inf}}{is\_inf}}\label{is_inf}

\texttt{is\_inf} --- trig / math (batch 2) builtin. Alias for
\texttt{is\_infinite}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_inf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_inf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_infinite}}{is\_infinite}}\label{is_infinite}

\texttt{is\_infinite} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_infinite $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_infinite |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_int}}{is\_int}}\label{is_int}

\texttt{is\_int} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_integer}}{is\_integer}}\label{is_integer}

\texttt{is\_integer} --- trivial type predicates builtin. Alias for
\texttt{is\_int}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_integer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_integer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_ipv4}}{is\_ipv4}}\label{is_ipv4}

\texttt{is\_ipv4} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_ipv4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_ipv4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_ipv4\_addr}}{is\_ipv4\_addr}}\label{is_ipv4_addr}

\texttt{is\_ipv4\_addr} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_ipv4\_addr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_ipv4\_addr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_ipv6\_addr}}{is\_ipv6\_addr}}\label{is_ipv6_addr}

\texttt{is\_ipv6\_addr} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_ipv6\_addr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_ipv6\_addr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_isbn10}}{is\_isbn10}}\label{is_isbn10}

\texttt{is\_isbn10} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_isbn10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_isbn10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_isbn13}}{is\_isbn13}}\label{is_isbn13}

\texttt{is\_isbn13} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_isbn13 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_isbn13 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_iso\_date}}{is\_iso\_date}}\label{is_iso_date}

\texttt{is\_iso\_date} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_iso\_date $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_iso\_date |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_iso\_datetime}}{is\_iso\_datetime}}\label{is_iso_datetime}

\texttt{is\_iso\_datetime} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_iso\_datetime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_iso\_datetime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_iso\_time}}{is\_iso\_time}}\label{is_iso_time}

\texttt{is\_iso\_time} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_iso\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_iso\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_isogram}}{is\_isogram}}\label{is_isogram}

\texttt{is\_isogram} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_isogram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_isogram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_json}}{is\_json}}\label{is_json}

\texttt{is\_json} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_json $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_json |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_kaprekar}}{is\_kaprekar}}\label{is_kaprekar}

\texttt{is\_kaprekar} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_kaprekar $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_kaprekar |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_keith}}{is\_keith}}\label{is_keith}

\texttt{is\_keith} --- batch 11 builtin. Alias for \texttt{keith\_q}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_keith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_keith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_leap}}{is\_leap}}\label{is_leap}

\texttt{is\_leap} --- date helpers builtin. Alias for
\texttt{is\_leap\_year}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_leap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_leap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_leap\_year}}{is\_leap\_year}}\label{is_leap_year}

\texttt{is\_leap\_year} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_leap\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_leap\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_lower}}{is\_lower}}\label{is_lower}

\texttt{is\_lower} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_mac\_addr}}{is\_mac\_addr}}\label{is_mac_addr}

\texttt{is\_mac\_addr} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_mac\_addr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_mac\_addr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_match}}{is\_match}}\label{is_match}

\texttt{is\_match} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_monotonic}}{is\_monotonic}}\label{is_monotonic}

\texttt{is\_monotonic} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_monotonic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_monotonic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_multiple\_of}}{is\_multiple\_of}}\label{is_multiple_of}

\texttt{is\_multiple\_of} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_multiple\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_multiple\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_nan}}{is\_nan}}\label{is_nan}

\texttt{is\_nan} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_nan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_nan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_narcissistic}}{is\_narcissistic}}\label{is_narcissistic}

\texttt{is\_narcissistic} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_narcissistic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_narcissistic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_negative}}{is\_negative}}\label{is_negative}

\texttt{is\_negative} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_negative $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_negative |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_negative\_num}}{is\_negative\_num}}\label{is_negative_num}

\texttt{is\_negative\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_negative\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_negative\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_nil}}{is\_nil}}\label{is_nil}

\texttt{is\_nil} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_nil $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_nil |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_nonzero}}{is\_nonzero}}\label{is_nonzero}

\texttt{is\_nonzero} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_nonzero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_nonzero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_numeric}}{is\_numeric}}\label{is_numeric}

\texttt{is\_numeric} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_numeric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_numeric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_numeric\_string}}{is\_numeric\_string}}\label{is_numeric_string}

\texttt{is\_numeric\_string} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_numeric\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_numeric\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_octal\_str}}{is\_octal\_str}}\label{is_octal_str}

\texttt{is\_octal\_str} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_octal\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_octal\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_odd}}{is\_odd}}\label{is_odd}

\texttt{is\_odd} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_odd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_odd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_odd\_num}}{is\_odd\_num}}\label{is_odd_num}

\texttt{is\_odd\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_odd\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_odd\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_pair}}{is\_pair}}\label{is_pair}

\texttt{is\_pair} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_pair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_pair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_palindrome}}{is\_palindrome}}\label{is_palindrome}

\texttt{is\_palindrome} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_palindrome $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_palindrome |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_pangram}}{is\_pangram}}\label{is_pangram}

\texttt{is\_pangram} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_pangram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_pangram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_pentagonal}}{is\_pentagonal}}\label{is_pentagonal}

\texttt{is\_pentagonal} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_pentagonal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_pentagonal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_perfect}}{is\_perfect}}\label{is_perfect}

\texttt{is\_perfect} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_perfect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_perfect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_perfect\_square}}{is\_perfect\_square}}\label{is_perfect_square}

\texttt{is\_perfect\_square} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_perfect\_square $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_perfect\_square |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_permutation}}{is\_permutation}}\label{is_permutation}

\texttt{is\_permutation} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_permutation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_permutation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_phone\_num}}{is\_phone\_num}}\label{is_phone_num}

\texttt{is\_phone\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_phone\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_phone\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_port\_num}}{is\_port\_num}}\label{is_port_num}

\texttt{is\_port\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_port\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_port\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_positive}}{is\_positive}}\label{is_positive}

\texttt{is\_positive} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_positive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_positive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_positive\_num}}{is\_positive\_num}}\label{is_positive_num}

\texttt{is\_positive\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_positive\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_positive\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_pow2}}{is\_pow2}}\label{is_pow2}

\texttt{is\_pow2} --- trivial numeric / predicate builtins builtin.
Alias for \texttt{is\_power\_of\_two}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_pow2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_pow2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_power\_of}}{is\_power\_of}}\label{is_power_of}

\texttt{is\_power\_of} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_power\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_power\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_power\_of\_two}}{is\_power\_of\_two}}\label{is_power_of_two}

\texttt{is\_power\_of\_two} --- trivial numeric / predicate builtins
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_power\_of\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_power\_of\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_prefix}}{is\_prefix}}\label{is_prefix}

\texttt{is\_prefix} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_prefix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_prefix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_present}}{is\_present}}\label{is_present}

\texttt{is\_present} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_present $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_present |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_prime}}{is\_prime}}\label{is_prime}

\texttt{is\_prime} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_prime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_prime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_printable}}{is\_printable}}\label{is_printable}

\texttt{is\_printable} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_printable $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_printable |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_probable\_prime}}{is\_probable\_prime}}\label{is_probable_prime}

\texttt{miller\_rabin} (aliases \texttt{millerrabin},
\texttt{is\_probable\_prime}) performs a probabilistic primality test
with k rounds (default 20).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p millerrabin(104729)     \# 1 (prime)}
\NormalTok{p millerrabin(104730)     \# 0 (composite)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_readable}}{is\_readable}}\label{is_readable}

\texttt{is\_readable} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_readable $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_readable |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_ref}}{is\_ref}}\label{is_ref}

\texttt{is\_ref} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_ref $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_ref |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_regex\_valid}}{is\_regex\_valid}}\label{is_regex_valid}

\texttt{is\_regex\_valid} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_regex\_valid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_regex\_valid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_root}}{is\_root}}\label{is_root}

\texttt{is\_root} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_semver}}{is\_semver}}\label{is_semver}

\texttt{is\_semver} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_semver $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_semver |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_slug}}{is\_slug}}\label{is_slug}

\texttt{is\_slug} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_slug $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_slug |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_smith}}{is\_smith}}\label{is_smith}

\texttt{is\_smith} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_smith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_smith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_sorted}}{is\_sorted}}\label{is_sorted}

\texttt{is\_sorted} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_sorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_sorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_sorted\_by}}{is\_sorted\_by}}\label{is_sorted_by}

\texttt{is\_sorted\_by} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_sorted\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_sorted\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_sorted\_desc}}{is\_sorted\_desc}}\label{is_sorted_desc}

\texttt{is\_sorted\_desc} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_sorted\_desc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_sorted\_desc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_space}}{is\_space}}\label{is_space}

\texttt{is\_space} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_space $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_space |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_sphenic}}{is\_sphenic}}\label{is_sphenic}

\texttt{is\_sphenic} --- batch 10 builtin. Alias for
\texttt{sphenic\_q}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_sphenic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_sphenic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_square}}{is\_square}}\label{is_square}

\texttt{is\_square} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_square $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_square |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_squarefree}}{is\_squarefree}}\label{is_squarefree}

\texttt{is\_squarefree} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_squarefree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_squarefree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_str}}{is\_str}}\label{is_str}

\texttt{is\_str} --- trivial type predicates builtin. Alias for
\texttt{is\_string}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_strictly\_decreasing}}{is\_strictly\_decreasing}}\label{is_strictly_decreasing}

\texttt{is\_strictly\_decreasing} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_strictly\_decreasing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_strictly\_decreasing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_strictly\_increasing}}{is\_strictly\_increasing}}\label{is_strictly_increasing}

\texttt{is\_strictly\_increasing} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_strictly\_increasing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_strictly\_increasing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_string}}{is\_string}}\label{is_string}

\texttt{is\_string} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_subset}}{is\_subset}}\label{is_subset}

\texttt{is\_subset} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_subset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_subset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_suffix}}{is\_suffix}}\label{is_suffix}

\texttt{is\_suffix} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_suffix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_suffix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_superset}}{is\_superset}}\label{is_superset}

\texttt{is\_superset} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_superset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_superset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_symlink}}{is\_symlink}}\label{is_symlink}

\texttt{is\_symlink} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_symlink $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_symlink |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_tree}}{is\_tree}}\label{is_tree}

\texttt{is\_tree} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_tree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_tree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_triangular}}{is\_triangular}}\label{is_triangular}

\texttt{is\_triangular} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_triangular $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_triangular |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_triple}}{is\_triple}}\label{is_triple}

\texttt{is\_triple} --- predicates (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_triple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_triple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_truthy}}{is\_truthy}}\label{is_truthy}

\texttt{is\_truthy} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_truthy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_truthy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_tty}}{is\_tty}}\label{is_tty}

\texttt{is\_tty} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_tty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_tty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_undef}}{is\_undef}}\label{is_undef}

\texttt{is\_undef} --- trivial type predicates builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_undef $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_undef |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_upper}}{is\_upper}}\label{is_upper}

\texttt{is\_upper} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_upper $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_upper |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_url}}{is\_url}}\label{is_url}

\texttt{is\_url} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_url $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_url |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_us\_zip}}{is\_us\_zip}}\label{is_us_zip}

\texttt{is\_us\_zip} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_us\_zip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_us\_zip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_uuid}}{is\_uuid}}\label{is_uuid}

\texttt{is\_uuid} --- id helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_uuid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_uuid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_cidr}}{is\_valid\_cidr}}\label{is_valid_cidr}

\texttt{is\_valid\_cidr} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_cidr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_cidr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_cron}}{is\_valid\_cron}}\label{is_valid_cron}

\texttt{is\_valid\_cron} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_cron $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_cron |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_date}}{is\_valid\_date}}\label{is_valid_date}

\texttt{is\_valid\_date} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_date $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_date |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_email}}{is\_valid\_email}}\label{is_valid_email}

\texttt{is\_valid\_email} --- network / validation builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_email $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_email |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_hex}}{is\_valid\_hex}}\label{is_valid_hex}

\texttt{is\_valid\_hex} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_hex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_hex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_hex\_color}}{is\_valid\_hex\_color}}\label{is_valid_hex_color}

\texttt{is\_valid\_hex\_color} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_hex\_color $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_hex\_color |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_ipv4}}{is\_valid\_ipv4}}\label{is_valid_ipv4}

\texttt{is\_valid\_ipv4} --- network / validation builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_ipv4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_ipv4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_ipv6}}{is\_valid\_ipv6}}\label{is_valid_ipv6}

\texttt{is\_valid\_ipv6} --- network / validation builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_ipv6 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_ipv6 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_latitude}}{is\_valid\_latitude}}\label{is_valid_latitude}

\texttt{is\_valid\_latitude} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_latitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_latitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_longitude}}{is\_valid\_longitude}}\label{is_valid_longitude}

\texttt{is\_valid\_longitude} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_longitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_longitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_mime}}{is\_valid\_mime}}\label{is_valid_mime}

\texttt{is\_valid\_mime} --- dsp / signal (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_mime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_mime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_valid\_url}}{is\_valid\_url}}\label{is_valid_url}

\texttt{is\_valid\_url} --- network / validation builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_valid\_url $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_valid\_url |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_vowel}}{is\_vowel}}\label{is_vowel}

\texttt{is\_vowel} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_vowel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_vowel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_weekday}}{is\_weekday}}\label{is_weekday}

\texttt{is\_weekday} --- date (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_weekday $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_weekday |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_weekend}}{is\_weekend}}\label{is_weekend}

\texttt{is\_weekend} --- date (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_weekend $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_weekend |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_whitespace}}{is\_whitespace}}\label{is_whitespace}

\texttt{is\_whitespace} --- trivial string ops builtin. Alias for
\texttt{is\_space}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_whitespace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_whitespace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_whole}}{is\_whole}}\label{is_whole}

\texttt{is\_whole} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_whole $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_whole |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_whole\_num}}{is\_whole\_num}}\label{is_whole_num}

\texttt{is\_whole\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_whole\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_whole\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_writable}}{is\_writable}}\label{is_writable}

\texttt{is\_writable} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_writable $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_writable |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_zero}}{is\_zero}}\label{is_zero}

\texttt{is\_zero} --- predicates (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{is\_zero\_num}}{is\_zero\_num}}\label{is_zero_num}

\texttt{is\_zero\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = is\_zero\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map is\_zero\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isabun}}{isabun}}\label{isabun}

\texttt{isabun} --- number theory / primes builtin. Alias for
\texttt{is\_abundant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isabun $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isabun |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isanag}}{isanag}}\label{isanag}

\texttt{isanag} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_anagram}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isanag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isanag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isasc}}{isasc}}\label{isasc}

\texttt{isasc} --- extended stdlib builtin. Alias for
\texttt{is\_ascii}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isasc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isasc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isb64}}{isb64}}\label{isb64}

\texttt{isb64} --- extended stdlib builtin. Alias for
\texttt{is\_base64}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isb64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isb64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbalp}}{isbalp}}\label{isbalp}

\texttt{isbalp} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_balanced\_parens}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbalp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbalp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbin}}{isbin}}\label{isbin}

\texttt{isbin} --- extended stdlib builtin. Alias for
\texttt{is\_binary\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbip}}{isbip}}\label{isbip}

\texttt{isbip} --- extended stdlib builtin. Alias for
\texttt{is\_bipartite\_graph}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbn10}}{isbn10}}\label{isbn10}

\texttt{isbn10} --- extended stdlib builtin. Alias for
\texttt{is\_isbn10}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbn10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbn10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbn10\_check}}{isbn10\_check}}\label{isbn10_check}

\texttt{isbn10\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbn10\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbn10\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbn13}}{isbn13}}\label{isbn13}

\texttt{isbn13} --- extended stdlib builtin. Alias for
\texttt{is\_isbn13}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbn13 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbn13 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isbn13\_check}}{isbn13\_check}}\label{isbn13_check}

\texttt{isbn13\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isbn13\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isbn13\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iscc}}{iscc}}\label{iscc}

\texttt{iscc} --- extended stdlib builtin. Alias for
\texttt{is\_credit\_card}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iscc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iscc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iscidr}}{iscidr}}\label{iscidr}

\texttt{iscidr} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_valid\_cidr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iscidr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iscidr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isco\_radius\_kerr\_step}}{isco\_radius\_kerr\_step}}\label{isco_radius_kerr_step}

\texttt{isco\_radius\_kerr\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isco\_radius\_kerr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isco\_radius\_kerr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iscopr}}{iscopr}}\label{iscopr}

\texttt{iscopr} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_coprime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iscopr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iscopr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iscron}}{iscron}}\label{iscron}

\texttt{iscron} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_valid\_cron}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iscron $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iscron |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isctrl}}{isctrl}}\label{isctrl}

\texttt{isctrl} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_control}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isctrl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isctrl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isdefi}}{isdefi}}\label{isdefi}

\texttt{isdefi} --- number theory / primes builtin. Alias for
\texttt{is\_deficient}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isdefi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isdefi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iseven}}{iseven}}\label{iseven}

\texttt{iseven} --- extended stdlib builtin. Alias for
\texttt{is\_even\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iseven $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iseven |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isharsh}}{isharsh}}\label{isharsh}

\texttt{isharsh} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_harshad}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isharsh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isharsh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ishet}}{ishet}}\label{ishet}

\texttt{ishet} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_heterogram}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ishet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ishet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ishex}}{ishex}}\label{ishex}

\texttt{ishex} --- extended stdlib builtin. Alias for
\texttt{is\_hex\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ishex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ishex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ishexc}}{ishexc}}\label{ishexc}

\texttt{ishexc} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_valid\_hex\_color}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ishexc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ishexc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ishost}}{ishost}}\label{ishost}

\texttt{ishost} --- extended stdlib builtin. Alias for
\texttt{is\_hostname\_valid}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ishost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ishost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isiban}}{isiban}}\label{isiban}

\texttt{isiban} --- extended stdlib builtin. Alias for
\texttt{is\_iban}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isiban $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isiban |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isip4}}{isip4}}\label{isip4}

\texttt{isip4} --- extended stdlib builtin. Alias for
\texttt{is\_ipv4\_addr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isip4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isip4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isip6}}{isip6}}\label{isip6}

\texttt{isip6} --- extended stdlib builtin. Alias for
\texttt{is\_ipv6\_addr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isip6 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isip6 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isiso}}{isiso}}\label{isiso}

\texttt{isiso} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_isogram}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isiso $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isiso |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isisodt}}{isisodt}}\label{isisodt}

\texttt{isisodt} --- extended stdlib builtin. Alias for
\texttt{is\_iso\_date}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isisodt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isisodt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isisodtm}}{isisodtm}}\label{isisodtm}

\texttt{isisodtm} --- extended stdlib builtin. Alias for
\texttt{is\_iso\_datetime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isisodtm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isisodtm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isisotm}}{isisotm}}\label{isisotm}

\texttt{isisotm} --- extended stdlib builtin. Alias for
\texttt{is\_iso\_time}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isisotm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isisotm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isjson}}{isjson}}\label{isjson}

\texttt{isjson} --- extended stdlib builtin. Alias for
\texttt{is\_json}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isjson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isjson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iskap}}{iskap}}\label{iskap}

\texttt{iskap} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_kaprekar}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iskap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iskap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isl}}{isl}}\label{isl}

\texttt{isl} --- python/ruby stdlib builtin. Alias for \texttt{islice}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{islamic\_leap\_year}}{islamic\_leap\_year}}\label{islamic_leap_year}

\texttt{islamic\_leap\_year} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = islamic\_leap\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map islamic\_leap\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{island\_equilibrium}}{island\_equilibrium}}\label{island_equilibrium}

\texttt{island\_equilibrium} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = island\_equilibrium $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map island\_equilibrium |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{islat}}{islat}}\label{islat}

\texttt{islat} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_valid\_latitude}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = islat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map islat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{islice}}{islice}}\label{islice}

\texttt{islice} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = islice $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map islice |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{islon}}{islon}}\label{islon}

\texttt{islon} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_valid\_longitude}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = islon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map islon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ism}}{ism}}\label{ism}

\texttt{ism} --- extended stdlib builtin. Alias for \texttt{is\_match}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ism $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ism |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ismac}}{ismac}}\label{ismac}

\texttt{ismac} --- extended stdlib builtin. Alias for
\texttt{is\_mac\_addr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ismac $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ismac |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ismime}}{ismime}}\label{ismime}

\texttt{ismime} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_valid\_mime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ismime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ismime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ismono}}{ismono}}\label{ismono}

\texttt{ismono} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_monotonic}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ismono $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ismono |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isnarc}}{isnarc}}\label{isnarc}

\texttt{isnarc} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_narcissistic}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isnarc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isnarc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isneg}}{isneg}}\label{isneg}

\texttt{isneg} --- extended stdlib builtin. Alias for
\texttt{is\_negative\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isneg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isneg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isnumstr}}{isnumstr}}\label{isnumstr}

\texttt{isnumstr} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_numeric\_string}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isnumstr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isnumstr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso226\_phon\_adjustment}}{iso226\_phon\_adjustment}}\label{iso226_phon_adjustment}

\texttt{iso226\_phon\_adjustment} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso226\_phon\_adjustment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso226\_phon\_adjustment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso8601\_duration\_parse}}{iso8601\_duration\_parse}}\label{iso8601_duration_parse}

\texttt{iso8601\_duration\_parse} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso8601\_duration\_parse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso8601\_duration\_parse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso8601\_duration\_to\_seconds}}{iso8601\_duration\_to\_seconds}}\label{iso8601_duration_to_seconds}

\texttt{iso8601\_duration\_to\_seconds} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso8601\_duration\_to\_seconds $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso\_day\_number}}{iso\_day\_number}}\label{iso_day_number}

\texttt{iso\_day\_number} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso\_day\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso\_day\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso\_dow}}{iso\_dow}}\label{iso_dow}

\texttt{iso\_dow} --- batch 9 builtin. Alias for
\texttt{day\_of\_week\_iso}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso\_dow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso\_dow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso\_ordinal\_date}}{iso\_ordinal\_date}}\label{iso_ordinal_date}

\texttt{iso\_ordinal\_date} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso\_ordinal\_date $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso\_ordinal\_date |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso\_week}}{iso\_week}}\label{iso_week}

\texttt{iso\_week} --- batch 9 builtin. Alias for
\texttt{iso\_week\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso\_week $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso\_week |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso\_week\_date}}{iso\_week\_date}}\label{iso_week_date}

\texttt{iso\_week\_date} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso\_week\_date $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso\_week\_date |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iso\_week\_number}}{iso\_week\_number}}\label{iso_week_number}

\texttt{iso\_week\_number} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iso\_week\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iso\_week\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isoct}}{isoct}}\label{isoct}

\texttt{isoct} --- extended stdlib builtin. Alias for
\texttt{is\_octal\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isoct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isoct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isodd}}{isodd}}\label{isodd}

\texttt{isodd} --- extended stdlib builtin. Alias for
\texttt{is\_odd\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isodd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isodd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isoelectric\_point\_protein}}{isoelectric\_point\_protein}}\label{isoelectric_point_protein}

\texttt{isoelectric\_point\_protein} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isoelectric\_point\_protein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isoelectric\_point\_protein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isolated\_horizon\_charge}}{isolated\_horizon\_charge}}\label{isolated_horizon_charge}

\texttt{isolated\_horizon\_charge} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isolated\_horizon\_charge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isolated\_horizon\_charge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isotropic\_relation\_check}}{isotropic\_relation\_check}}\label{isotropic_relation_check}

\texttt{isotropic\_relation\_check} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isotropic\_relation\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isotropic\_relation\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isp}}{isp}}\label{isp}

\texttt{isp} --- haskell list functions builtin. Alias for
\texttt{intersperse\_val}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ispang}}{ispang}}\label{ispang}

\texttt{ispang} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_pangram}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ispang $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ispang |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ispent}}{ispent}}\label{ispent}

\texttt{ispent} --- number theory / primes builtin. Alias for
\texttt{is\_pentagonal}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ispent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ispent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isperf}}{isperf}}\label{isperf}

\texttt{isperf} --- number theory / primes builtin. Alias for
\texttt{is\_perfect}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isperf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isperf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isphone}}{isphone}}\label{isphone}

\texttt{isphone} --- extended stdlib builtin. Alias for
\texttt{is\_phone\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isphone $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isphone |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isport}}{isport}}\label{isport}

\texttt{isport} --- extended stdlib builtin. Alias for
\texttt{is\_port\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isport $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isport |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ispos}}{ispos}}\label{ispos}

\texttt{ispos} --- extended stdlib builtin. Alias for
\texttt{is\_positive\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ispos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ispos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isprint}}{isprint}}\label{isprint}

\texttt{isprint} --- dsp / signal (extended) builtin. Alias for
\texttt{is\_printable}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isprint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isprint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ispw}}{ispw}}\label{ispw}

\texttt{ispw} --- additional missing stdlib functions builtin. Alias for
\texttt{intersperse\_with}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ispw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ispw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isslug}}{isslug}}\label{isslug}

\texttt{isslug} --- extended stdlib builtin. Alias for
\texttt{is\_slug}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isslug $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isslug |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{issmith}}{issmith}}\label{issmith}

\texttt{issmith} --- number theory / primes builtin. Alias for
\texttt{is\_smith}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = issmith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map issmith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{issqfr}}{issqfr}}\label{issqfr}

\texttt{issqfr} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_squarefree}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = issqfr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map issqfr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{issrtb}}{issrtb}}\label{issrtb}

\texttt{issrtb} --- additional missing stdlib functions builtin. Alias
for \texttt{is\_sorted\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = issrtb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map issrtb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{issv}}{issv}}\label{issv}

\texttt{issv} --- extended stdlib builtin. Alias for
\texttt{is\_semver}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = issv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map issv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ista\_step}}{ista\_step}}\label{ista_step}

\texttt{ista\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ista\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ista\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{istft\_step}}{istft\_step}}\label{istft_step}

\texttt{istft\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = istft\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map istft\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isvdate}}{isvdate}}\label{isvdate}

\texttt{isvdate} --- extended stdlib batch 3 builtin. Alias for
\texttt{is\_valid\_date}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isvdate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isvdate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iswap\_gate}}{iswap\_gate}}\label{iswap_gate}

\texttt{iswap\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iswap\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iswap\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{isweak}}{isweak}}\label{isweak}

\texttt{isweak} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = isweak $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map isweak |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iswhole}}{iswhole}}\label{iswhole}

\texttt{iswhole} --- extended stdlib builtin. Alias for
\texttt{is\_whole\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iswhole $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iswhole |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iszero}}{iszero}}\label{iszero}

\texttt{iszero} --- extended stdlib builtin. Alias for
\texttt{is\_zero\_num}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iszero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iszero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iszip}}{iszip}}\label{iszip}

\texttt{iszip} --- extended stdlib builtin. Alias for
\texttt{is\_us\_zip}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iszip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iszip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{italic}}{italic}}\label{italic}

\texttt{italic} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = italic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map italic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{itcz\_position\_lat}}{itcz\_position\_lat}}\label{itcz_position_lat}

\texttt{itcz\_position\_lat} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = itcz\_position\_lat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map itcz\_position\_lat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iter}}{iter}}\label{iter}

\texttt{iter} --- algebraic match builtin. Alias for \texttt{iterate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iterate}}{iterate}}\label{iterate}

\texttt{iterate} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iterate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iterate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iterate\_n}}{iterate\_n}}\label{iterate_n}

\texttt{iterate\_n} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iterate\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iterate\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iv}}{iv}}\label{iv}

\texttt{iv} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{iv\_estimator}}{iv\_estimator}}\label{iv_estimator}

\texttt{iv\_estimator} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = iv\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map iv\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jaccard}}{jaccard}}\label{jaccard}

\texttt{jaccard} --- extended stdlib batch 3 builtin. Alias for
\texttt{jaccard\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jaccard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jaccard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jaccard\_index}}{jaccard\_index}}\label{jaccard_index}

\texttt{jaccard\_index} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jaccard\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jaccard\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jaccard\_similarity}}{jaccard\_similarity}}\label{jaccard_similarity}

\texttt{jaccard\_similarity} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jaccard\_similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jaccard\_similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jacobi\_cn\_small\_q}}{jacobi\_cn\_small\_q}}\label{jacobi_cn_small_q}

\texttt{jacobi\_cn\_small\_q} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jacobi\_cn\_small\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jacobi\_cn\_small\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jacobi\_dn\_small\_q}}{jacobi\_dn\_small\_q}}\label{jacobi_dn_small_q}

\texttt{jacobi\_dn\_small\_q} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jacobi\_dn\_small\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jacobi\_dn\_small\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jacobi\_sn\_small\_q}}{jacobi\_sn\_small\_q}}\label{jacobi_sn_small_q}

\texttt{jacobi\_sn\_small\_q} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jacobi\_sn\_small\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jacobi\_sn\_small\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jacobian\_2dof}}{jacobian\_2dof}}\label{jacobian_2dof}

\texttt{jacobian\_2dof} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jacobian\_2dof $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jacobian\_2dof |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jahn\_teller\_check}}{jahn\_teller\_check}}\label{jahn_teller_check}

\texttt{jahn\_teller\_check} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jahn\_teller\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jahn\_teller\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jaro\_similarity}}{jaro\_similarity}}\label{jaro_similarity}

\texttt{jaro\_similarity} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jaro\_similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jaro\_similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jarosim}}{jarosim}}\label{jarosim}

\texttt{jarosim} --- extended stdlib batch 3 builtin. Alias for
\texttt{jaro\_similarity}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jarosim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jarosim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jd}}{jd}}\label{jd}

\texttt{jd} --- data / network builtin. Alias for \texttt{json\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jd\_to\_calendar}}{jd\_to\_calendar}}\label{jd_to_calendar}

\texttt{jd\_to\_calendar} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jd\_to\_calendar $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{je}}{je}}\label{je}

\texttt{je} --- data / network builtin. Alias for \texttt{json\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = je $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map je |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jeans\_length}}{jeans\_length}}\label{jeans_length}

\texttt{jeans\_length} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jeans\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jeans\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jenkins\_oat}}{jenkins\_oat}}\label{jenkins_oat}

\texttt{jenkins\_oat} --- batch 11 builtin. Alias for
\texttt{jenkins\_one\_at\_a\_time}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jenkins\_oat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jenkins\_oat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jenkins\_one\_at\_a\_time}}{jenkins\_one\_at\_a\_time}}\label{jenkins_one_at_a_time}

\texttt{jenkins\_one\_at\_a\_time} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jenkins\_one\_at\_a\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jenkins\_one\_at\_a\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jensen\_alpha}}{jensen\_alpha}}\label{jensen_alpha}

\texttt{jensen\_alpha} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jensen\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jensen\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jensen\_shannon\_div}}{jensen\_shannon\_div}}\label{jensen_shannon_div}

\texttt{jensen\_shannon\_div} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jensen\_shannon\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jensen\_shannon\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jensens\_alpha}}{jensens\_alpha}}\label{jensens_alpha}

\texttt{jensens\_alpha} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jensens\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jensens\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{job\_shop\_makespan\_lower}}{job\_shop\_makespan\_lower}}\label{job_shop_makespan_lower}

\texttt{job\_shop\_makespan\_lower} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = job\_shop\_makespan\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map job\_shop\_makespan\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{johansen\_test}}{johansen\_test}}\label{johansen_test}

\texttt{johansen\_test} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = johansen\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map johansen\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{johansen\_trace\_step}}{johansen\_trace\_step}}\label{johansen_trace_step}

\texttt{johansen\_trace\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = johansen\_trace\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map johansen\_trace\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{johnson\_2m}}{johnson\_2m}}\label{johnson_2m}

\texttt{johnson\_2m} --- batch 10 builtin. Alias for
\texttt{johnsons\_rule}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = johnson\_2m $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map johnson\_2m |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{johnson\_reweight}}{johnson\_reweight}}\label{johnson_reweight}

\texttt{johnson\_reweight} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = johnson\_reweight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map johnson\_reweight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{johnsons\_rule}}{johnsons\_rule}}\label{johnsons_rule}

\texttt{johnsons\_rule} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = johnsons\_rule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map johnsons\_rule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_colons}}{join\_colons}}\label{join_colons}

\texttt{join\_colons} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_colons $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_colons |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_commas}}{join\_commas}}\label{join_commas}

\texttt{join\_commas} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_commas $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_commas |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_dashes}}{join\_dashes}}\label{join_dashes}

\texttt{join\_dashes} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_dashes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_dashes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_dots}}{join\_dots}}\label{join_dots}

\texttt{join\_dots} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_dots $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_dots |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_lines}}{join\_lines}}\label{join_lines}

\texttt{join\_lines} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_lines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_lines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_pipes}}{join\_pipes}}\label{join_pipes}

\texttt{join\_pipes} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_pipes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_pipes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_slashes}}{join\_slashes}}\label{join_slashes}

\texttt{join\_slashes} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_slashes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_slashes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_spaces}}{join\_spaces}}\label{join_spaces}

\texttt{join\_spaces} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_spaces $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_spaces |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{join\_tabs}}{join\_tabs}}\label{join_tabs}

\texttt{join\_tabs} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = join\_tabs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map join\_tabs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{joint\_entropy\_step}}{joint\_entropy\_step}}\label{joint_entropy_step}

\texttt{joint\_entropy\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = joint\_entropy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map joint\_entropy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jones\_polynomial\_at\_i}}{jones\_polynomial\_at\_i}}\label{jones_polynomial_at_i}

\texttt{jones\_polynomial\_at\_i} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jones\_polynomial\_at\_i $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jones\_polynomial\_at\_i |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jones\_polynomial\_at\_minus\_one}}{jones\_polynomial\_at\_minus\_one}}\label{jones_polynomial_at_minus_one}

\texttt{jones\_polynomial\_at\_minus\_one} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jones\_polynomial\_at\_minus\_one $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jones\_polynomial\_at\_minus\_one |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{joule\_heating\_battery}}{joule\_heating\_battery}}\label{joule_heating_battery}

\texttt{joule\_heating\_battery} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = joule\_heating\_battery $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map joule\_heating\_battery |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{joules\_to\_cal}}{joules\_to\_cal}}\label{joules_to_cal}

\texttt{joules\_to\_cal} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = joules\_to\_cal $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{joules\_to\_ev}}{joules\_to\_ev}}\label{joules_to_ev}

\texttt{joules\_to\_ev} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = joules\_to\_ev $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jpeg\_dct\_8x8\_quant}}{jpeg\_dct\_8x8\_quant}}\label{jpeg_dct_8x8_quant}

\texttt{jpeg\_dct\_8x8\_quant} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jpeg\_dct\_8x8\_quant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jpeg\_dct\_8x8\_quant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jpeg\_zig\_zag\_index}}{jpeg\_zig\_zag\_index}}\label{jpeg_zig_zag_index}

\texttt{jpeg\_zig\_zag\_index} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jpeg\_zig\_zag\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jpeg\_zig\_zag\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jr\_european\_call}}{jr\_european\_call}}\label{jr_european_call}

\texttt{jr\_european\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jr\_european\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jr\_european\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_array\_length}}{json\_array\_length}}\label{json_array_length}

\texttt{json\_array\_length} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_array\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_array\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_build\_object}}{json\_build\_object}}\label{json_build_object}

\texttt{json\_build\_object} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_build\_object $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_build\_object |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_each}}{json\_each}}\label{json_each}

\texttt{json\_each} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_escape}}{json\_escape}}\label{json_escape}

\texttt{json\_escape} --- json helpers builtin. Alias for
\texttt{escape\_json}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_escape $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_escape |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_extract\_path}}{json\_extract\_path}}\label{json_extract_path}

\texttt{json\_extract\_path} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_extract\_path $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_extract\_path |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_minify}}{json\_minify}}\label{json_minify}

\texttt{json\_minify} --- json helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_minify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_minify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_pretty}}{json\_pretty}}\label{json_pretty}

\texttt{json\_pretty} --- json helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_pretty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_pretty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{json\_strip\_nulls}}{json\_strip\_nulls}}\label{json_strip_nulls}

\texttt{json\_strip\_nulls} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = json\_strip\_nulls $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map json\_strip\_nulls |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jsonb\_array\_length}}{jsonb\_array\_length}}\label{jsonb_array_length}

\texttt{jsonb\_array\_length} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jsonb\_array\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jsonb\_array\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jsonb\_object\_keys}}{jsonb\_object\_keys}}\label{jsonb_object_keys}

\texttt{jsonb\_object\_keys} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jsonb\_object\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jsonb\_object\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jsonb\_path\_query}}{jsonb\_path\_query}}\label{jsonb_path_query}

\texttt{jsonb\_path\_query} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jsonb\_path\_query $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jsonb\_path\_query |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jsonb\_pretty}}{jsonb\_pretty}}\label{jsonb_pretty}

\texttt{jsonb\_pretty} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jsonb\_pretty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jsonb\_pretty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jsonb\_set}}{jsonb\_set}}\label{jsonb_set}

\texttt{jsonb\_set} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jsonb\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jsonb\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jsonb\_typeof}}{jsonb\_typeof}}\label{jsonb_typeof}

\texttt{jsonb\_typeof} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jsonb\_typeof $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jsonb\_typeof |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jukes\_cantor\_distance}}{jukes\_cantor\_distance}}\label{jukes_cantor_distance}

\texttt{jukes\_cantor\_distance} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jukes\_cantor\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jukes\_cantor\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{julian\_centuries\_j2000}}{julian\_centuries\_j2000}}\label{julian_centuries_j2000}

\texttt{julian\_centuries\_j2000} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = julian\_centuries\_j2000 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map julian\_centuries\_j2000 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{julian\_day}}{julian\_day}}\label{julian_day}

\texttt{julian\_day} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = julian\_day $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map julian\_day |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{julian\_from\_fixed}}{julian\_from\_fixed}}\label{julian_from_fixed}

\texttt{julian\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = julian\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map julian\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{just\_intonation\_freq}}{just\_intonation\_freq}}\label{just_intonation_freq}

\texttt{just\_intonation\_freq} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = just\_intonation\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map just\_intonation\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{just\_intonation\_ratio}}{just\_intonation\_ratio}}\label{just_intonation_ratio}

\texttt{just\_intonation\_ratio} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = just\_intonation\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map just\_intonation\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{juxt2}}{juxt2}}\label{juxt2}

\texttt{juxt2} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = juxt2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map juxt2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{juxt3}}{juxt3}}\label{juxt3}

\texttt{juxt3} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = juxt3 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map juxt3 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{jv}}{jv}}\label{jv}

\texttt{jv} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = jv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map jv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{k\_coreness}}{k\_coreness}}\label{k_coreness}

\texttt{k\_coreness} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = k\_coreness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map k\_coreness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{k\_from\_dg}}{k\_from\_dg}}\label{k_from_dg}

\texttt{k\_from\_dg} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = k\_from\_dg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map k\_from\_dg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{k\_shortest\_spanning}}{k\_shortest\_spanning}}\label{k_shortest_spanning}

\texttt{k\_shortest\_spanning} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = k\_shortest\_spanning $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map k\_shortest\_spanning |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{k\_to\_c}}{k\_to\_c}}\label{k_to_c}

\texttt{k\_to\_c} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = k\_to\_c $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{k\_to\_f}}{k\_to\_f}}\label{k_to_f}

\texttt{k\_to\_f} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = k\_to\_f $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ka\_to\_pka}}{ka\_to\_pka}}\label{ka_to_pka}

\texttt{ka\_to\_pka} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ka\_to\_pka $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kaiser}}{kaiser}}\label{kaiser}

\texttt{window\_kaiser(\$n,\ \$beta)} (alias \texttt{kaiser}) ---
generates a Kaiser window with parameter beta controlling the tradeoff
between main lobe width and sidelobe level. Beta=0 is rectangular,
beta\textasciitilde5 is similar to Hamming.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $w = kaiser(1024, 5.0)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kaiser\_window}}{kaiser\_window}}\label{kaiser_window}

\texttt{kaiser\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kaiser\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kaiser\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kaiserord\_step}}{kaiserord\_step}}\label{kaiserord_step}

\texttt{kaiserord\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kaiserord\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kaiserord\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kalai\_smorodinsky\_step}}{kalai\_smorodinsky\_step}}\label{kalai_smorodinsky_step}

\texttt{kalai\_smorodinsky\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kalai\_smorodinsky\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kalai\_smorodinsky\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kalman\_filter\_step}}{kalman\_filter\_step}}\label{kalman_filter_step}

\texttt{kalman\_filter\_step} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kalman\_filter\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kalman\_filter\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kalman\_predict\_state}}{kalman\_predict\_state}}\label{kalman_predict_state}

\texttt{kalman\_predict\_state} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kalman\_predict\_state $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kalman\_predict\_state |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kalman\_smoother\_step}}{kalman\_smoother\_step}}\label{kalman_smoother_step}

\texttt{kalman\_smoother\_step} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kalman\_smoother\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kalman\_smoother\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kalman\_update\_state}}{kalman\_update\_state}}\label{kalman_update_state}

\texttt{kalman\_update\_state} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kalman\_update\_state $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kalman\_update\_state |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kaluza\_klein\_step}}{kaluza\_klein\_step}}\label{kaluza_klein_step}

\texttt{kaluza\_klein\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kaluza\_klein\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kaluza\_klein\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kaprekar\_routine\_step}}{kaprekar\_routine\_step}}\label{kaprekar_routine_step}

\texttt{kaprekar\_routine\_step} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kaprekar\_routine\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kaprekar\_routine\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{karger\_contract\_edge}}{karger\_contract\_edge}}\label{karger_contract_edge}

\texttt{karger\_contract\_edge} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = karger\_contract\_edge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map karger\_contract\_edge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{karger\_min\_cut\_count}}{karger\_min\_cut\_count}}\label{karger_min_cut_count}

\texttt{karger\_min\_cut\_count} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = karger\_min\_cut\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map karger\_min\_cut\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{karger\_step}}{karger\_step}}\label{karger_step}

\texttt{karger\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = karger\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map karger\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{karhunen\_loeve\_step}}{karhunen\_loeve\_step}}\label{karhunen_loeve_step}

\texttt{karhunen\_loeve\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = karhunen\_loeve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map karhunen\_loeve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kasiski\_repeats}}{kasiski\_repeats}}\label{kasiski_repeats}

\texttt{kasiski\_repeats} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kasiski\_repeats $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kasiski\_repeats |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{katz\_centrality}}{katz\_centrality}}\label{katz_centrality}

\texttt{katz\_centrality} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = katz\_centrality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map katz\_centrality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kauffman\_bracket\_eval}}{kauffman\_bracket\_eval}}\label{kauffman_bracket_eval}

\texttt{kauffman\_bracket\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kauffman\_bracket\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kauffman\_bracket\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kb\_to\_b}}{kb\_to\_b}}\label{kb_to_b}

\texttt{kb\_to\_b} --- unit conversions builtin. Alias for
\texttt{kb\_to\_bytes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kb\_to\_b $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kb\_to\_bytes}}{kb\_to\_bytes}}\label{kb_to_bytes}

\texttt{kb\_to\_bytes} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kb\_to\_bytes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kb\_to\_mb}}{kb\_to\_mb}}\label{kb_to_mb}

\texttt{kb\_to\_mb} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kb\_to\_mb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kc\_from\_rates}}{kc\_from\_rates}}\label{kc_from_rates}

\texttt{kc\_from\_rates} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kc\_from\_rates $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kc\_from\_rates |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kcoulomb}}{kcoulomb}}\label{kcoulomb}

\texttt{kcoulomb} --- physics constants builtin. Alias for
\texttt{coulomb\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kcoulomb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kcoulomb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_bandwidth\_lscv}}{kde\_bandwidth\_lscv}}\label{kde_bandwidth_lscv}

\texttt{kde\_bandwidth\_lscv} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_bandwidth\_lscv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_bandwidth\_lscv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_biweight}}{kde\_biweight}}\label{kde_biweight}

\texttt{kde\_biweight} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_biweight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_biweight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_cosine}}{kde\_cosine}}\label{kde_cosine}

\texttt{kde\_cosine} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_cosine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_cosine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_epanechnikov}}{kde\_epanechnikov}}\label{kde_epanechnikov}

\texttt{kde\_epanechnikov} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_epanechnikov $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_epanechnikov |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_gaussian\_2d}}{kde\_gaussian\_2d}}\label{kde_gaussian_2d}

\texttt{kde\_gaussian\_2d} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_gaussian\_2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_gaussian\_2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_logistic\_kernel}}{kde\_logistic\_kernel}}\label{kde_logistic_kernel}

\texttt{kde\_logistic\_kernel} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_logistic\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_logistic\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_scott\_bw}}{kde\_scott\_bw}}\label{kde_scott_bw}

\texttt{kde\_scott\_bw} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_scott\_bw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_scott\_bw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_silverman\_bw}}{kde\_silverman\_bw}}\label{kde_silverman_bw}

\texttt{kde\_silverman\_bw} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_silverman\_bw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_silverman\_bw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_triangular}}{kde\_triangular}}\label{kde_triangular}

\texttt{kde\_triangular} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_triangular $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_triangular |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_triweight}}{kde\_triweight}}\label{kde_triweight}

\texttt{kde\_triweight} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_triweight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_triweight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kde\_uniform}}{kde\_uniform}}\label{kde_uniform}

\texttt{kde\_uniform} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kde\_uniform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kde\_uniform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{keep}}{keep}}\label{keep}

\texttt{keep} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = keep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map keep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{keep\_if}}{keep\_if}}\label{keep_if}

\texttt{keep\_if} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = keep\_if $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map keep\_if |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{keith\_q}}{keith\_q}}\label{keith_q}

\texttt{keith\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = keith\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map keith\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kelly\_criterion}}{kelly\_criterion}}\label{kelly_criterion}

\texttt{kelly\_criterion} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kelly\_criterion $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kelly\_criterion |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kemeny\_score\_step}}{kemeny\_score\_step}}\label{kemeny_score_step}

\texttt{kemeny\_score\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kemeny\_score\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kemeny\_score\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kendall}}{kendall}}\label{kendall}

\texttt{kendall\_tau} (aliases \texttt{kendall}, \texttt{ktau}) computes
Kendall\textquotesingle s rank correlation coefficient (tau-b).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ktau([1,2,3,4], [1,2,4,3])  \# 0.67}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kendalltau}}{kendalltau}}\label{kendalltau}

\texttt{kendalltau} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kendalltau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kendalltau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kepler\_hyperbolic}}{kepler\_hyperbolic}}\label{kepler_hyperbolic}

\texttt{kepler\_hyperbolic} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kepler\_hyperbolic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kepler\_hyperbolic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kepler\_period\_au}}{kepler\_period\_au}}\label{kepler_period_au}

\texttt{kepler\_period\_au} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kepler\_period\_au $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kepler\_period\_au |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kerr\_ergosphere\_eq}}{kerr\_ergosphere\_eq}}\label{kerr_ergosphere_eq}

\texttt{kerr\_ergosphere\_eq} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kerr\_ergosphere\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kerr\_ergosphere\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kerr\_horizon}}{kerr\_horizon}}\label{kerr_horizon}

\texttt{kerr\_horizon} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kerr\_horizon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kerr\_horizon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kerr\_newman\_charge\_term}}{kerr\_newman\_charge\_term}}\label{kerr_newman_charge_term}

\texttt{kerr\_newman\_charge\_term} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kerr\_newman\_charge\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kerr\_newman\_charge\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{key\_signature\_flats}}{key\_signature\_flats}}\label{key_signature_flats}

\texttt{key\_signature\_flats} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = key\_signature\_flats $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map key\_signature\_flats |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{key\_signature\_for}}{key\_signature\_for}}\label{key_signature_for}

\texttt{key\_signature\_for} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = key\_signature\_for $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map key\_signature\_for |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{key\_signature\_sharps}}{key\_signature\_sharps}}\label{key_signature_sharps}

\texttt{key\_signature\_sharps} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = key\_signature\_sharps $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map key\_signature\_sharps |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{keys\_sorted}}{keys\_sorted}}\label{keys_sorted}

\texttt{keys\_sorted} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = keys\_sorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map keys\_sorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kg\_to\_lb}}{kg\_to\_lb}}\label{kg_to_lb}

\texttt{kg\_to\_lb} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kg\_to\_lb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kg\_to\_lbs}}{kg\_to\_lbs}}\label{kg_to_lbs}

\texttt{kg\_to\_lbs} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kg\_to\_lbs $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kg\_to\_stone}}{kg\_to\_stone}}\label{kg_to_stone}

\texttt{kg\_to\_stone} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kg\_to\_stone $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{khinchin}}{khinchin}}\label{khinchin}

\texttt{khinchin} --- math constants builtin. Alias for
\texttt{khinchin\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = khinchin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map khinchin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{khinchin\_constant}}{khinchin\_constant}}\label{khinchin_constant}

\texttt{khinchin\_constant} --- math constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = khinchin\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map khinchin\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{khovanov\_q\_grading}}{khovanov\_q\_grading}}\label{khovanov_q_grading}

\texttt{khovanov\_q\_grading} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = khovanov\_q\_grading $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map khovanov\_q\_grading |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{khovanov\_rasmussen\_s}}{khovanov\_rasmussen\_s}}\label{khovanov_rasmussen_s}

\texttt{khovanov\_rasmussen\_s} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = khovanov\_rasmussen\_s $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map khovanov\_rasmussen\_s |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{killing\_form\_su2}}{killing\_form\_su2}}\label{killing_form_su2}

\texttt{killing\_form\_su2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = killing\_form\_su2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map killing\_form\_su2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{killing\_vector\_lie\_step}}{killing\_vector\_lie\_step}}\label{killing_vector_lie_step}

\texttt{killing\_vector\_lie\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = killing\_vector\_lie\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map killing\_vector\_lie\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kimura\_2p\_distance}}{kimura\_2p\_distance}}\label{kimura_2p_distance}

\texttt{kimura\_2p\_distance} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kimura\_2p\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kimura\_2p\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kinetic\_energy}}{kinetic\_energy}}\label{kinetic_energy}

\texttt{kinetic\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kinetic\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kinetic\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kirnberger\_iii}}{kirnberger\_iii}}\label{kirnberger_iii}

\texttt{kirnberger\_iii} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kirnberger\_iii $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kirnberger\_iii |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kleibers\_law}}{kleibers\_law}}\label{kleibers_law}

\texttt{kleibers\_law} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kleibers\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kleibers\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{km\_to\_miles}}{km\_to\_miles}}\label{km_to_miles}

\texttt{km\_to\_miles} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = km\_to\_miles $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kmeans}}{kmeans}}\label{kmeans}

\texttt{kmeans} --- k-means clustering (Lloyd\textquotesingle s
algorithm). Takes array of points and k. Returns cluster assignments.
Like R\textquotesingle s kmeans().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @clusters = @\{kmeans([[0,0],[1,0],[10,10],[11,10]], 2)\}}
\NormalTok{\# [0,0,1,1] — two clusters}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kmer\_jaccard}}{kmer\_jaccard}}\label{kmer_jaccard}

\texttt{kmer\_jaccard} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kmer\_jaccard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kmer\_jaccard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kmh\_to\_mph}}{kmh\_to\_mph}}\label{kmh_to_mph}

\texttt{kmh\_to\_mph} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kmh\_to\_mph $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kmh\_to\_mps}}{kmh\_to\_mps}}\label{kmh_to_mps}

\texttt{kmh\_to\_mps} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kmh\_to\_mps $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kmp}}{kmp}}\label{kmp}

\texttt{kmp} --- batch 10 builtin. Alias for \texttt{kmp\_failure}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kmp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kmp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kmp\_failure}}{kmp\_failure}}\label{kmp_failure}

\texttt{kmp\_failure} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kmp\_failure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kmp\_failure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{knapsack\_01\_dp\_value}}{knapsack\_01\_dp\_value}}\label{knapsack_01_dp_value}

\texttt{knapsack\_01\_dp\_value} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = knapsack\_01\_dp\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map knapsack\_01\_dp\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{knapsack\_branch\_bound}}{knapsack\_branch\_bound}}\label{knapsack_branch_bound}

\texttt{knapsack\_branch\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = knapsack\_branch\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map knapsack\_branch\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{knapsack\_fractional\_step}}{knapsack\_fractional\_step}}\label{knapsack_fractional_step}

\texttt{knapsack\_fractional\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = knapsack\_fractional\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map knapsack\_fractional\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{knapsack\_lp\_relaxation}}{knapsack\_lp\_relaxation}}\label{knapsack_lp_relaxation}

\texttt{knapsack\_lp\_relaxation} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = knapsack\_lp\_relaxation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map knapsack\_lp\_relaxation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{knapsack\_unbounded\_dp}}{knapsack\_unbounded\_dp}}\label{knapsack_unbounded_dp}

\texttt{knapsack\_unbounded\_dp} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = knapsack\_unbounded\_dp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map knapsack\_unbounded\_dp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{knots\_to\_kmh}}{knots\_to\_kmh}}\label{knots_to_kmh}

\texttt{knots\_to\_kmh} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = knots\_to\_kmh $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kohlrausch\_law}}{kohlrausch\_law}}\label{kohlrausch_law}

\texttt{kohlrausch\_law} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kohlrausch\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kohlrausch\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kolmogorov\_microscale}}{kolmogorov\_microscale}}\label{kolmogorov_microscale}

\texttt{kolmogorov\_microscale} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kolmogorov\_microscale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kolmogorov\_microscale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kolmogorov\_smirnov}}{kolmogorov\_smirnov}}\label{kolmogorov_smirnov}

\texttt{kolmogorov\_smirnov} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kolmogorov\_smirnov $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kolmogorov\_smirnov |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{komar\_mass\_step}}{komar\_mass\_step}}\label{komar_mass_step}

\texttt{komar\_mass\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = komar\_mass\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map komar\_mass\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kosaraju\_scc}}{kosaraju\_scc}}\label{kosaraju_scc}

\texttt{kosaraju\_scc} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kosaraju\_scc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kosaraju\_scc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kosaraju\_step}}{kosaraju\_step}}\label{kosaraju_step}

\texttt{kosaraju\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kosaraju\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kosaraju\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{koutecky\_levich\_intercept}}{koutecky\_levich\_intercept}}\label{koutecky_levich_intercept}

\texttt{koutecky\_levich\_intercept} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = koutecky\_levich\_intercept $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map koutecky\_levich\_intercept |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kp}}{kp}}\label{kp}

\texttt{kp} --- algebraic match builtin. Alias for \texttt{keep}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kp\_from\_kc}}{kp\_from\_kc}}\label{kp_from_kc}

\texttt{kp\_from\_kc} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kp\_from\_kc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kp\_from\_kc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kpss\_test}}{kpss\_test}}\label{kpss_test}

\texttt{kpss\_test} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kpss\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kpss\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kpss\_test\_stat}}{kpss\_test\_stat}}\label{kpss_test_stat}

\texttt{kpss\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kpss\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kpss\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kraus\_apply}}{kraus\_apply}}\label{kraus_apply}

\texttt{kraus\_apply} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kraus\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kraus\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kretschmann\_schwarzschild}}{kretschmann\_schwarzschild}}\label{kretschmann_schwarzschild}

\texttt{kretschmann\_schwarzschild} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kretschmann\_schwarzschild $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kretschmann\_schwarzschild |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kron\_product}}{kron\_product}}\label{kron_product}

\texttt{kron\_product} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kron\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kron\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kronecker\_four}}{kronecker\_four}}\label{kronecker_four}

\texttt{kronecker\_four} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kronecker\_four $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kronecker\_four |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kronecker\_three}}{kronecker\_three}}\label{kronecker_three}

\texttt{kronecker\_three} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kronecker\_three $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kronecker\_three |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kruskal\_h}}{kruskal\_h}}\label{kruskal_h}

\texttt{kruskal\_h} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kruskal\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kruskal\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kruskal\_step}}{kruskal\_step}}\label{kruskal_step}

\texttt{kruskal\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kruskal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kruskal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ks}}{ks}}\label{ks}

\texttt{ks\_test} (alias \texttt{ks}) --- two-sample Kolmogorov-Smirnov
test. Returns D statistic (max CDF difference). Like R\textquotesingle s
ks.test().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $D = ks([1,2,3,4,5], [2,3,4,5,6])  \# small D = similar}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ksp\_from\_concs}}{ksp\_from\_concs}}\label{ksp_from_concs}

\texttt{ksp\_from\_concs} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ksp\_from\_concs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ksp\_from\_concs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kth\_largest}}{kth\_largest}}\label{kth_largest}

\texttt{kth\_largest} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kth\_largest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kth\_largest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kth\_smallest}}{kth\_smallest}}\label{kth_smallest}

\texttt{kth\_smallest} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kth\_smallest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kth\_smallest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kthl}}{kthl}}\label{kthl}

\texttt{kthl} --- extended stdlib batch 3 builtin. Alias for
\texttt{kth\_largest}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kthl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kthl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kths}}{kths}}\label{kths}

\texttt{kths} --- extended stdlib batch 3 builtin. Alias for
\texttt{kth\_smallest}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kths $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kths |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kullback\_jensen\_div}}{kullback\_jensen\_div}}\label{kullback_jensen_div}

\texttt{kullback\_jensen\_div} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kullback\_jensen\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kullback\_jensen\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kurt}}{kurt}}\label{kurt}

\texttt{kurt} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{kurtosis}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kurt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kurt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kurtosis}}{kurtosis}}\label{kurtosis}

\texttt{kurtosis} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kurtosis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kurtosis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kv}}{kv}}\label{kv}

\texttt{kv} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map kv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{kwh\_to\_joules}}{kwh\_to\_joules}}\label{kwh_to_joules}

\texttt{kwh\_to\_joules} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = kwh\_to\_joules $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{l1\_coherence}}{l1\_coherence}}\label{l1_coherence}

\texttt{l1\_coherence} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = l1\_coherence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map l1\_coherence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{l1\_norm}}{l1\_norm}}\label{l1_norm}

\texttt{l1\_norm} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = l1\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map l1\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{l2\_norm}}{l2\_norm}}\label{l2_norm}

\texttt{l2\_norm} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = l2\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map l2\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{l\_parallel}}{l\_parallel}}\label{l_parallel}

\texttt{l\_parallel} --- batch 12 builtin. Alias for
\texttt{inductance\_parallel}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = l\_parallel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map l\_parallel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{l\_series}}{l\_series}}\label{l_series}

\texttt{l\_series} --- batch 12 builtin. Alias for
\texttt{inductance\_series}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = l\_series $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map l\_series |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{label\_propagation}}{label\_propagation}}\label{label_propagation}

\texttt{label\_propagation} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = label\_propagation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map label\_propagation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{label\_propagation\_step}}{label\_propagation\_step}}\label{label_propagation_step}

\texttt{label\_propagation\_step} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = label\_propagation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map label\_propagation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lagrange}}{lagrange}}\label{lagrange}

\texttt{lagrange\_interp} (aliases \texttt{lagrange}, \texttt{linterp})
performs Lagrange polynomial interpolation. Takes xs, ys, and a query
point x.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lagrange([0,1,2], [0,1,4], 1.5)  \# 2.25}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lagrange\_l1}}{lagrange\_l1}}\label{lagrange_l1}

\texttt{lagrange\_l1} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lagrange\_l1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lagrange\_l1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lagrangian\_dual\_step}}{lagrangian\_dual\_step}}\label{lagrangian_dual_step}

\texttt{lagrangian\_dual\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lagrangian\_dual\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lagrangian\_dual\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lagrangian\_relax\_step}}{lagrangian\_relax\_step}}\label{lagrangian_relax_step}

\texttt{lagrangian\_relax\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lagrangian\_relax\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lagrangian\_relax\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lalr\_lookahead\_compute}}{lalr\_lookahead\_compute}}\label{lalr_lookahead_compute}

\texttt{lalr\_lookahead\_compute} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lalr\_lookahead\_compute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lalr\_lookahead\_compute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lambert\_azimuthal\_project}}{lambert\_azimuthal\_project}}\label{lambert_azimuthal_project}

\texttt{lambert\_azimuthal\_project} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lambert\_azimuthal\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lambert\_azimuthal\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lambert\_simple}}{lambert\_simple}}\label{lambert_simple}

\texttt{lambert\_simple} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lambert\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lambert\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lambert\_w}}{lambert\_w}}\label{lambert_w}

\texttt{lambert\_w} (aliases \texttt{lambertw}, \texttt{productlog})
computes the Lambert W function (principal branch): the inverse of f(w)
= w·e\^{}w.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lambertw(1)   \# 0.5671 (Omega constant)}
\NormalTok{p lambertw(exp(1))  \# 1.0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lambert\_w0}}{lambert\_w0}}\label{lambert_w0}

\texttt{lambert\_w0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lambert\_w0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lambert\_w0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lander\_waterman\_gaps}}{lander\_waterman\_gaps}}\label{lander_waterman_gaps}

\texttt{lander\_waterman\_gaps} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lander\_waterman\_gaps $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lander\_waterman\_gaps |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{laplace\_de\_rham\_step}}{laplace\_de\_rham\_step}}\label{laplace_de_rham_step}

\texttt{laplace\_de\_rham\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = laplace\_de\_rham\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map laplace\_de\_rham\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{laplace\_pdf}}{laplace\_pdf}}\label{laplace_pdf}

\texttt{laplace\_pdf} (alias \texttt{laplacepdf}) evaluates the Laplace
distribution PDF at x with location mu and scale b.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p laplacepdf(0, 0, 1)  \# 0.5 (peak)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{laplacian\_kernel\_value}}{laplacian\_kernel\_value}}\label{laplacian_kernel_value}

\texttt{laplacian\_kernel\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = laplacian\_kernel\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map laplacian\_kernel\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{larmor\_frequency}}{larmor\_frequency}}\label{larmor_frequency}

\texttt{larmor\_frequency} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = larmor\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map larmor\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_arg}}{last\_arg}}\label{last_arg}

\texttt{last\_arg} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_arg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_arg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_clj}}{last\_clj}}\label{last_clj}

\texttt{last\_clj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_clj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_clj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_elem}}{last\_elem}}\label{last_elem}

\texttt{last\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_eq}}{last\_eq}}\label{last_eq}

\texttt{last\_eq} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_index\_of}}{last\_index\_of}}\label{last_index_of}

\texttt{last\_index\_of} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_index\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_index\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_of\_month}}{last\_of\_month}}\label{last_of_month}

\texttt{last\_of\_month} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_of\_month $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_of\_month |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{last\_word}}{last\_word}}\label{last_word}

\texttt{last\_word} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = last\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map last\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lastc}}{lastc}}\label{lastc}

\texttt{lastc} --- algebraic match builtin. Alias for
\texttt{last\_clj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lastc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lastc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lat\_lng\_to\_tile\_xyz}}{lat\_lng\_to\_tile\_xyz}}\label{lat_lng_to_tile_xyz}

\texttt{lat\_lng\_to\_tile\_xyz} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lat\_lng\_to\_tile\_xyz $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lat\_lng\_to\_xy\_lambert}}{lat\_lng\_to\_xy\_lambert}}\label{lat_lng_to_xy_lambert}

\texttt{lat\_lng\_to\_xy\_lambert} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lat\_lng\_to\_xy\_lambert $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lat\_lng\_to\_xy\_mercator}}{lat\_lng\_to\_xy\_mercator}}\label{lat_lng_to_xy_mercator}

\texttt{lat\_lng\_to\_xy\_mercator} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lat\_lng\_to\_xy\_mercator $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lax\_friedrichs\_flux}}{lax\_friedrichs\_flux}}\label{lax_friedrichs_flux}

\texttt{lax\_friedrichs\_flux} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lax\_friedrichs\_flux $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lax\_friedrichs\_flux |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lax\_wendroff\_flux}}{lax\_wendroff\_flux}}\label{lax_wendroff_flux}

\texttt{lax\_wendroff\_flux} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lax\_wendroff\_flux $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lax\_wendroff\_flux |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lazy\_caterer}}{lazy\_caterer}}\label{lazy_caterer}

\texttt{lazy\_caterer} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lazy\_caterer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lazy\_caterer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lb\_to\_kg}}{lb\_to\_kg}}\label{lb_to_kg}

\texttt{lb\_to\_kg} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lb\_to\_kg $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lbf\_to\_newtons}}{lbf\_to\_newtons}}\label{lbf_to_newtons}

\texttt{lbf\_to\_newtons} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lbf\_to\_newtons $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lbound}}{lbound}}\label{lbound}

\texttt{lbound} --- extended stdlib builtin. Alias for
\texttt{lower\_bound}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lbound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lbound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lbs\_to\_kg}}{lbs\_to\_kg}}\label{lbs_to_kg}

\texttt{lbs\_to\_kg} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lbs\_to\_kg $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lc\_frequency}}{lc\_frequency}}\label{lc_frequency}

\texttt{lc\_frequency} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lc\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lc\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lc\_lines}}{lc\_lines}}\label{lc_lines}

\texttt{lc\_lines} --- trivial string ops builtin. Alias for
\texttt{line\_count}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lc\_lines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lc\_lines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lc\_omega}}{lc\_omega}}\label{lc_omega}

\texttt{lc\_omega} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lc\_omega $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lc\_omega |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lc\_resonant}}{lc\_resonant}}\label{lc_resonant}

\texttt{lc\_resonant} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lc\_resonant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lc\_resonant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcdm\_eos}}{lcdm\_eos}}\label{lcdm_eos}

\texttt{lcdm\_eos} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcdm\_eos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcdm\_eos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcg\_next\_u32}}{lcg\_next\_u32}}\label{lcg_next_u32}

\texttt{lcg\_next\_u32} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcg\_next\_u32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcg\_next\_u32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcg\_numrec\_step}}{lcg\_numrec\_step}}\label{lcg_numrec_step}

\texttt{lcg\_numrec\_step} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcg\_numrec\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcg\_numrec\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcm}}{lcm}}\label{lcm}

\texttt{lcm} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcontract}}{lcontract}}\label{lcontract}

\texttt{length\_contraction(\$proper\_length,\ \$velocity)} (alias
\texttt{lcontract}) --- contracted length L = L₀ × √(1-v²/c²).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lcontract(1, 0.99 * 3e8)   \# \textasciitilde{}0.14 m (1m at 99\% c)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcount}}{lcount}}\label{lcount}

\texttt{lcount} --- extended stdlib batch 3 builtin. Alias for
\texttt{count\_lines}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcp}}{lcp}}\label{lcp}

\texttt{lcp} --- string (batch 2) builtin. Alias for
\texttt{longest\_common\_prefix}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcp\_array}}{lcp\_array}}\label{lcp_array}

\texttt{lcp\_array} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcp\_array $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcp\_array |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcs\_length}}{lcs\_length}}\label{lcs_length}

\texttt{lcs\_length} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcs\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcs\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcseq}}{lcseq}}\label{lcseq}

\texttt{lcseq} --- extended stdlib batch 3 builtin. Alias for
\texttt{longest\_common\_subsequence}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcseq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcseq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lcsub}}{lcsub}}\label{lcsub}

\texttt{lcsub} --- extended stdlib batch 3 builtin. Alias for
\texttt{longest\_common\_substring}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lcsub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lcsub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ld\_d}}{ld\_d}}\label{ld_d}

\texttt{ld\_d} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ld\_d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ld\_d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ld\_r\_squared}}{ld\_r\_squared}}\label{ld_r_squared}

\texttt{ld\_r\_squared} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ld\_r\_squared $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ld\_r\_squared |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ldec}}{ldec}}\label{ldec}

\texttt{ldec} --- extended stdlib batch 3 builtin. Alias for
\texttt{longest\_decreasing}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ldec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ldec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{le\_chatelier\_dir}}{le\_chatelier\_dir}}\label{le_chatelier_dir}

\texttt{le\_chatelier\_dir} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = le\_chatelier\_dir $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map le\_chatelier\_dir |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leading\_zeros}}{leading\_zeros}}\label{leading_zeros}

\texttt{leading\_zeros} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leading\_zeros $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leading\_zeros |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leaky\_relu}}{leaky\_relu}}\label{leaky_relu}

\texttt{leaky\_relu} (alias \texttt{lrelu}) applies Leaky ReLU: x if
x≥0, alpha*x otherwise (default alpha=0.01).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lrelu(5)     \# 5}
\NormalTok{p lrelu({-}5)    \# {-}0.05}
\NormalTok{p lrelu({-}5, 0.1)  \# {-}0.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leap\_year\_gregorian}}{leap\_year\_gregorian}}\label{leap_year_gregorian}

\texttt{leap\_year\_gregorian} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leap\_year\_gregorian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leap\_year\_gregorian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leapfrog\_step}}{leapfrog\_step}}\label{leapfrog_step}

\texttt{leapfrog\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leapfrog\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leapfrog\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{least\_common}}{least\_common}}\label{least_common}

\texttt{least\_common} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = least\_common $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map least\_common |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leet}}{leet}}\label{leet}

\texttt{leet} --- string processing (uncategorized batch) builtin. Alias
for \texttt{leetspeak}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leetspeak}}{leetspeak}}\label{leetspeak}

\texttt{leetspeak} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leetspeak $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leetspeak |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{left\_str}}{left\_str}}\label{left_str}

\texttt{left\_str} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = left\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map left\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lehmer\_mean}}{lehmer\_mean}}\label{lehmer_mean}

\texttt{lehmer\_mean} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lehmer\_mean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lehmer\_mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lemmatize\_lemmy}}{lemmatize\_lemmy}}\label{lemmatize_lemmy}

\texttt{lemmatize\_lemmy} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lemmatize\_lemmy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lemmatize\_lemmy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lemmatize\_wordnet}}{lemmatize\_wordnet}}\label{lemmatize_wordnet}

\texttt{lemmatize\_wordnet} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lemmatize\_wordnet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lemmatize\_wordnet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{length\_each}}{length\_each}}\label{length_each}

\texttt{length\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = length\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map length\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lens\_focal\_length}}{lens\_focal\_length}}\label{lens_focal_length}

\texttt{lens\_focal\_length} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lens\_focal\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lens\_focal\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lens\_magnification}}{lens\_magnification}}\label{lens_magnification}

\texttt{lens\_magnification} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lens\_magnification $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lens\_magnification |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lens\_power}}{lens\_power}}\label{lens_power}

\texttt{lens\_power} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lens\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lens\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lense\_thirring\_omega}}{lense\_thirring\_omega}}\label{lense_thirring_omega}

\texttt{lense\_thirring\_omega} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lense\_thirring\_omega $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lense\_thirring\_omega |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lensing\_convergence}}{lensing\_convergence}}\label{lensing_convergence}

\texttt{lensing\_convergence} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lensing\_convergence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lensing\_convergence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lensmaker}}{lensmaker}}\label{lensmaker}

\texttt{lensmaker} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lensmaker $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lensmaker |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leontief\_input}}{leontief\_input}}\label{leontief_input}

\texttt{leontief\_input} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leontief\_input $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leontief\_input |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leontief\_output}}{leontief\_output}}\label{leontief_output}

\texttt{leontief\_output} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leontief\_output $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leontief\_output |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lerner\_index}}{lerner\_index}}\label{lerner_index}

\texttt{lerner\_index} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lerner\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lerner\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lerp}}{lerp}}\label{lerp}

\texttt{lerp(\$a,\ \$b,\ \$t)} --- linear interpolation between a and b.
When t=0 returns a, t=1 returns b, t=0.5 returns midpoint.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lerp(0, 100, 0.5)   \# 50}
\NormalTok{p lerp(10, 20, 0.25)  \# 12.5}
\NormalTok{\# Animation: smoothly transition between values}
\NormalTok{for my $t (0:10) \{ p lerp($start, $end, $t/10) \}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lerp\_color}}{lerp\_color}}\label{lerp_color}

\texttt{lerp\_color} --- batch 9 builtin. Alias for
\texttt{color\_blend\_t}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lerp\_color $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lerp\_color |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leslie\_step}}{leslie\_step}}\label{leslie_step}

\texttt{leslie\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leslie\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leslie\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{less}}{less}}\label{less}

\texttt{LIST\ \textbar{}\textgreater{}\ pager} / \texttt{pager\ LIST}
--- pipe each element (one per line) into the user\textquotesingle s
\texttt{\$PAGER} (default \texttt{less\ -R}; falls back to
\texttt{more}, then plain stdout). Bypasses the pager when stdout
isn\textquotesingle t a TTY so pipelines like
\texttt{stryke\ \textquotesingle{}...\ \textbar{}\textgreater{}\ pager\textquotesingle{}\ \textbar{}\ grep}
still compose.

Blocks until the user quits the pager; returns \texttt{undef}.

Aliases: \texttt{pager}, \texttt{pg}, \texttt{less}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# browse every callable spelling interactively}
\NormalTok{keys \%all |\textgreater{} sort |\textgreater{} pager}

\NormalTok{\# filter the reference for parallel ops}
\NormalTok{keys \%b |\textgreater{} grep \{ $b\{\_\} eq "parallel" \} |\textgreater{} pager}

\NormalTok{\# whole file, one screen at a time}
\NormalTok{slurp("README.md") |\textgreater{} pager}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{letter\_frequency}}{letter\_frequency}}\label{letter_frequency}

\texttt{letter\_frequency} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = letter\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map letter\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{letters\_lc}}{letters\_lc}}\label{letters_lc}

\texttt{letters\_lc} extracts only lowercase letters from a string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p join "", letters\_lc("Hello World 123")  \# elloorld}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{letters\_uc}}{letters\_uc}}\label{letters_uc}

\texttt{letters\_uc} extracts only uppercase letters from a string.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p join "", letters\_uc("Hello World 123")  \# HW}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lev}}{lev}}\label{lev}

\texttt{lev} --- extended stdlib builtin. Alias for
\texttt{levenshtein}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lev $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lev |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{level\_k\_step}}{level\_k\_step}}\label{level_k_step}

\texttt{level\_k\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = level\_k\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map level\_k\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{level\_premium}}{level\_premium}}\label{level_premium}

\texttt{level\_premium} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = level\_premium $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map level\_premium |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levenshtein}}{levenshtein}}\label{levenshtein}

\texttt{levenshtein} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levenshtein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levenshtein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levenshtein\_dist}}{levenshtein\_dist}}\label{levenshtein_dist}

\texttt{levenshtein\_dist} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levenshtein\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levenshtein\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{leverage\_index}}{leverage\_index}}\label{leverage_index}

\texttt{leverage\_index} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = leverage\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map leverage\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levi\_civita\_four}}{levi\_civita\_four}}\label{levi_civita_four}

\texttt{levi\_civita\_four} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levi\_civita\_four $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levi\_civita\_four |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levi\_civita\_three}}{levi\_civita\_three}}\label{levi_civita_three}

\texttt{levi\_civita\_three} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levi\_civita\_three $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levi\_civita\_three |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levich\_current\_rde}}{levich\_current\_rde}}\label{levich_current_rde}

\texttt{levich\_current\_rde} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levich\_current\_rde $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levich\_current\_rde |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levin\_t\_transform}}{levin\_t\_transform}}\label{levin_t_transform}

\texttt{levin\_t\_transform} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levin\_t\_transform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levin\_t\_transform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{levy\_pdf}}{levy\_pdf}}\label{levy_pdf}

\texttt{levy\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = levy\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map levy\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lewis\_dot\_count}}{lewis\_dot\_count}}\label{lewis_dot_count}

\texttt{lewis\_dot\_count} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lewis\_dot\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lewis\_dot\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lex\_keyword\_classify}}{lex\_keyword\_classify}}\label{lex_keyword_classify}

\texttt{lex\_keyword\_classify} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lex\_keyword\_classify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lex\_keyword\_classify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lexicalized\_parse}}{lexicalized\_parse}}\label{lexicalized_parse}

\texttt{lexicalized\_parse} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lexicalized\_parse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lexicalized\_parse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lfilter\_zi\_init}}{lfilter\_zi\_init}}\label{lfilter_zi_init}

\texttt{lfilter\_zi\_init} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lfilter\_zi\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lfilter\_zi\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lfrm}}{lfrm}}\label{lfrm}

\texttt{lfrm} --- go/general functional utilities builtin. Alias for
\texttt{lines\_from}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lfrm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lfrm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lfsr\_galois\_step}}{lfsr\_galois\_step}}\label{lfsr_galois_step}

\texttt{lfsr\_galois\_step} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lfsr\_galois\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lfsr\_galois\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lie\_derivative\_scalar\_step}}{lie\_derivative\_scalar\_step}}\label{lie_derivative_scalar_step}

\texttt{lie\_derivative\_scalar\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lie\_derivative\_scalar\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lie\_derivative\_scalar\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lie\_derivative\_vector\_step}}{lie\_derivative\_vector\_step}}\label{lie_derivative_vector_step}

\texttt{lie\_derivative\_vector\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lie\_derivative\_vector\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lie\_derivative\_vector\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lie\_split}}{lie\_split}}\label{lie_split}

\texttt{lie\_split} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lie\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lie\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{life\_expectancy\_e0}}{life\_expectancy\_e0}}\label{life_expectancy_e0}

\texttt{life\_expectancy\_e0} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = life\_expectancy\_e0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map life\_expectancy\_e0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{light\_deflection\_angle}}{light\_deflection\_angle}}\label{light_deflection_angle}

\texttt{light\_deflection\_angle} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = light\_deflection\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map light\_deflection\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{light\_year}}{light\_year}}\label{light_year}

\texttt{light\_year} (alias \texttt{ly}) --- ly ≈ 9.461×10¹⁵ m. Distance
light travels in one year.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ly             \# 9.4607304725808e15 m}
\NormalTok{p ly / au        \# \textasciitilde{}63241 AU}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{likelihood\_ratio\_test}}{likelihood\_ratio\_test}}\label{likelihood_ratio_test}

\texttt{likelihood\_ratio\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = likelihood\_ratio\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map likelihood\_ratio\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{limiting\_current\_density}}{limiting\_current\_density}}\label{limiting_current_density}

\texttt{limiting\_current\_density} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = limiting\_current\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map limiting\_current\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lin\_bairstow\_step}}{lin\_bairstow\_step}}\label{lin_bairstow_step}

\texttt{lin\_bairstow\_step} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lin\_bairstow\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lin\_bairstow\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lin\_kernighan\_step}}{lin\_kernighan\_step}}\label{lin_kernighan_step}

\texttt{lin\_kernighan\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lin\_kernighan\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lin\_kernighan\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linc}}{linc}}\label{linc}

\texttt{linc} --- extended stdlib batch 3 builtin. Alias for
\texttt{longest\_increasing}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{line\_count}}{line\_count}}\label{line_count}

\texttt{line\_count} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = line\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map line\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{line\_count\_simple}}{line\_count\_simple}}\label{line_count_simple}

\texttt{line\_count\_simple} --- batch 11 builtin. Alias for
\texttt{string\_lines\_count}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = line\_count\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map line\_count\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{line\_intersection}}{line\_intersection}}\label{line_intersection}

\texttt{line\_intersection(\$x1,\ \$y1,\ \$x2,\ \$y2,\ \$x3,\ \$y3,\ \$x4,\ \$y4)}
--- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $pt = line\_intersection(0, 0, 1, 1, 0, 1, 1, 0)}
\NormalTok{p @$pt   \# (0.5, 0.5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linear\_entropy}}{linear\_entropy}}\label{linear_entropy}

\texttt{linear\_entropy} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linear\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linear\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linear\_regression}}{linear\_regression}}\label{linear_regression}

\texttt{linear\_regression} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linear\_regression $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linear\_regression |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linear\_search}}{linear\_search}}\label{linear_search}

\texttt{linear\_search} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linear\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linear\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linearized\_pb\_step}}{linearized\_pb\_step}}\label{linearized_pb_step}

\texttt{linearized\_pb\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linearized\_pb\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linearized\_pb\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lineintr}}{lineintr}}\label{lineintr}

\texttt{lineintr} --- geometry (extended) builtin. Alias for
\texttt{line\_intersection}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lineintr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lineintr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lines\_from}}{lines\_from}}\label{lines_from}

\texttt{lines\_from} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lines\_from $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lines\_from |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lineweaver\_burk}}{lineweaver\_burk}}\label{lineweaver_burk}

\texttt{lineweaver\_burk} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lineweaver\_burk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lineweaver\_burk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linf\_norm}}{linf\_norm}}\label{linf_norm}

\texttt{linf\_norm} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linf\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linf\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linking\_number\_two}}{linking\_number\_two}}\label{linking_number_two}

\texttt{linking\_number\_two} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linking\_number\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linking\_number\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linreg}}{linreg}}\label{linreg}

\texttt{linreg} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{linear\_regression}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linreg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linreg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{linspace}}{linspace}}\label{linspace}

\texttt{linspace} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = linspace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map linspace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{liouville}}{liouville}}\label{liouville}

\texttt{liouville} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = liouville $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map liouville |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{liquefaction\_potential\_index}}{liquefaction\_potential\_index}}\label{liquefaction_potential_index}

\texttt{liquefaction\_potential\_index} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = liquefaction\_potential\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map liquefaction\_potential\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_coloring\_step}}{list\_coloring\_step}}\label{list_coloring_step}

\texttt{list\_coloring\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_coloring\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_coloring\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_compact}}{list\_compact}}\label{list_compact}

\texttt{list\_compact} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_compact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_compact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_count}}{list\_count}}\label{list_count}

\texttt{list\_count} (alias \texttt{list\_size}) returns the total
number of elements after flattening a nested list structure. Unlike
\texttt{count} which returns the top-level element count,
\texttt{list\_count} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @nested = ([1, 2], [3, 4, 5], [6])}
\NormalTok{p list\_count @nested   \# 6}
\NormalTok{my @deep = ([1, [2, 3]], [4])}
\NormalTok{p list\_size @deep      \# 4}
\NormalTok{p list\_count 1, 2, 3   \# 3  (flat list works too)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_difference}}{list\_difference}}\label{list_difference}

\texttt{list\_difference} --- collection (batch 2) builtin. Alias for
\texttt{array\_difference}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_difference $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_difference |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_eq}}{list\_eq}}\label{list_eq}

\texttt{list\_eq} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_flatten\_deep}}{list\_flatten\_deep}}\label{list_flatten_deep}

\texttt{list\_flatten\_deep} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_flatten\_deep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_flatten\_deep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_intersection}}{list\_intersection}}\label{list_intersection}

\texttt{list\_intersection} --- collection (batch 2) builtin. Alias for
\texttt{array\_intersection}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_intersection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_intersection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_reverse}}{list\_reverse}}\label{list_reverse}

\texttt{list\_reverse} --- file stat / path builtin. Alias for
\texttt{reverse\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_reverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_reverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_scheduling\_step}}{list\_scheduling\_step}}\label{list_scheduling_step}

\texttt{list\_scheduling\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_scheduling\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_scheduling\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{list\_union}}{list\_union}}\label{list_union}

\texttt{list\_union} --- collection (batch 2) builtin. Alias for
\texttt{array\_union}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = list\_union $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map list\_union |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{liters\_to\_gallons}}{liters\_to\_gallons}}\label{liters_to_gallons}

\texttt{liters\_to\_gallons} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = liters\_to\_gallons $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{liters\_to\_ml}}{liters\_to\_ml}}\label{liters_to_ml}

\texttt{liters\_to\_ml} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = liters\_to\_ml $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lithium\_ion\_diffusivity}}{lithium\_ion\_diffusivity}}\label{lithium_ion_diffusivity}

\texttt{lithium\_ion\_diffusivity} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lithium\_ion\_diffusivity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lithium\_ion\_diffusivity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lix}}{lix}}\label{lix}

\texttt{lix} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ljt}}{ljt}}\label{ljt}

\texttt{ljt} --- extended stdlib builtin. Alias for
\texttt{ljust\_text}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ljt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ljt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ljung\_box\_q}}{ljung\_box\_q}}\label{ljung_box_q}

\texttt{ljung\_box\_q} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ljung\_box\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ljung\_box\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ljust}}{ljust}}\label{ljust}

\texttt{ljust} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ljust $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ljust |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ljust\_text}}{ljust\_text}}\label{ljust_text}

\texttt{ljust\_text} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ljust\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ljust\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lkpa}}{lkpa}}\label{lkpa}

\texttt{lkpa} --- haskell list functions builtin. Alias for
\texttt{lookup\_assoc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lkpa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lkpa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ll1\_first\_set}}{ll1\_first\_set}}\label{ll1_first_set}

\texttt{ll1\_first\_set} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ll1\_first\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ll1\_first\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ll1\_follow\_set}}{ll1\_follow\_set}}\label{ll1_follow_set}

\texttt{ll1\_follow\_set} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ll1\_follow\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ll1\_follow\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ll1\_predict\_table}}{ll1\_predict\_table}}\label{ll1_predict_table}

\texttt{ll1\_predict\_table} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ll1\_predict\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ll1\_predict\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lll\_2x2\_step}}{lll\_2x2\_step}}\label{lll_2x2_step}

\texttt{lll\_2x2\_step} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lll\_2x2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lll\_2x2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lm}}{lm}}\label{lm}

\texttt{lm\_fit} (alias \texttt{lm}) --- simple linear regression.
Returns hash with intercept, slope, r\_squared, residuals, fitted. Like
R\textquotesingle s lm().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%m = \%\{lm([1,2,3,4,5], [2,4,5,4,5])\}}
\NormalTok{p $m\{slope\}       \# slope}
\NormalTok{p $m\{r\_squared\}   \# R²}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lm\_step}}{lm\_step}}\label{lm_step}

\texttt{lm\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ln10}}{ln10}}\label{ln10}

\texttt{ln10} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ln10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ln10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ln2}}{ln2}}\label{ln2}

\texttt{ln2} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ln2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ln2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lnormpdf}}{lnormpdf}}\label{lnormpdf}

\texttt{lognormal\_pdf} (alias \texttt{lnormpdf}) evaluates the
log-normal distribution PDF at x with parameters mu and sigma.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lnormpdf(1.0, 0, 1)  \# LogN(0,1) at x=1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lns}}{lns}}\label{lns}

\texttt{lns} --- math / numeric (uncategorized batch) builtin. Alias for
\texttt{look\_and\_say}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lns $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lns |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{load\_avg}}{load\_avg}}\label{load_avg}

\texttt{load\_avg} --- system load averages as a 3-element arrayref
\texttt{{[}1min,\ 5min,\ 15min{]}}. Uses \texttt{getloadavg()} on unix.
Returns \texttt{undef} on unsupported platforms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $la = load\_avg}
\NormalTok{p "1m=$la{-}\textgreater{}[0] 5m=$la{-}\textgreater{}[1] 15m=$la{-}\textgreater{}[2]"}
\NormalTok{load\_avg |\textgreater{} spark |\textgreater{} p                   \# sparkline of load}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{load\_centrality}}{load\_centrality}}\label{load_centrality}

\texttt{load\_centrality} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = load\_centrality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map load\_centrality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{loan\_balance}}{loan\_balance}}\label{loan_balance}

\texttt{loan\_balance} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = loan\_balance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map loan\_balance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{loan\_payment\_pmt}}{loan\_payment\_pmt}}\label{loan_payment_pmt}

\texttt{loan\_payment\_pmt} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = loan\_payment\_pmt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map loan\_payment\_pmt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lobatto\_iiia\_2}}{lobatto\_iiia\_2}}\label{lobatto_iiia_2}

\texttt{lobatto\_iiia\_2} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lobatto\_iiia\_2 $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lobatto\_iiic\_3}}{lobatto\_iiic\_3}}\label{lobatto_iiic_3}

\texttt{lobatto\_iiic\_3} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lobatto\_iiic\_3 $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{local\_efficiency}}{local\_efficiency}}\label{local_efficiency}

\texttt{local\_efficiency} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = local\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map local\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{local\_search\_swap\_step}}{local\_search\_swap\_step}}\label{local_search_swap_step}

\texttt{local\_search\_swap\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = local\_search\_swap\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map local\_search\_swap\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{loess}}{loess}}\label{loess}

\texttt{lowess} (alias \texttt{loess}) --- locally-weighted scatterplot
smoothing (LOWESS/LOESS). Returns smoothed Y values with tricube
weighting.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @smooth = @\{lowess([1,2,3,4,5], [2,1,4,3,5])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log10}}{log10}}\label{log10}

\texttt{log10} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log1p\_exp}}{log1p\_exp}}\label{log1p_exp}

\texttt{log1p\_exp} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log1p\_exp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log1p\_exp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log2}}{log2}}\label{log2}

\texttt{log2} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_base}}{log\_base}}\label{log_base}

\texttt{log\_base} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_gamma\_simple}}{log\_gamma\_simple}}\label{log_gamma_simple}

\texttt{log\_gamma\_simple} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_gamma\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_gamma\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_law\_wind\_profile}}{log\_law\_wind\_profile}}\label{log_law_wind_profile}

\texttt{log\_law\_wind\_profile} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_law\_wind\_profile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_law\_wind\_profile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_loss}}{log\_loss}}\label{log_loss}

\texttt{log\_loss} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_sigmoid}}{log\_sigmoid}}\label{log_sigmoid}

\texttt{log\_sigmoid} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_sigmoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_sigmoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_softmax}}{log\_softmax}}\label{log_softmax}

\texttt{log\_softmax} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_softmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_softmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_sum\_exp}}{log\_sum\_exp}}\label{log_sum_exp}

\texttt{log\_sum\_exp} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_sum\_exp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_sum\_exp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{log\_with\_base}}{log\_with\_base}}\label{log_with_base}

\texttt{log\_with\_base} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = log\_with\_base $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map log\_with\_base |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{logb}}{logb}}\label{logb}

\texttt{logb} --- extended stdlib builtin. Alias for
\texttt{log\_with\_base}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = logb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map logb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{loggamma}}{loggamma}}\label{loggamma}

\texttt{loggamma} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = loggamma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map loggamma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{logistic\_growth\_analytic}}{logistic\_growth\_analytic}}\label{logistic_growth_analytic}

\texttt{logistic\_growth\_analytic} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = logistic\_growth\_analytic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map logistic\_growth\_analytic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{logistic\_growth\_step}}{logistic\_growth\_step}}\label{logistic_growth_step}

\texttt{logistic\_growth\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = logistic\_growth\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map logistic\_growth\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{logistic\_loss}}{logistic\_loss}}\label{logistic_loss}

\texttt{logistic\_loss} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = logistic\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map logistic\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{logit\_log\_likelihood}}{logit\_log\_likelihood}}\label{logit_log_likelihood}

\texttt{logit\_log\_likelihood} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = logit\_log\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map logit\_log\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lomax\_pdf}}{lomax\_pdf}}\label{lomax_pdf}

\texttt{lomax\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lomax\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lomax\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lombscargle\_freq}}{lombscargle\_freq}}\label{lombscargle_freq}

\texttt{lombscargle\_freq} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lombscargle\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lombscargle\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest}}{longest}}\label{longest}

\texttt{longest} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest\_common\_prefix}}{longest\_common\_prefix}}\label{longest_common_prefix}

\texttt{longest\_common\_prefix} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest\_common\_prefix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest\_common\_prefix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest\_common\_subsequence}}{longest\_common\_subsequence}}\label{longest_common_subsequence}

\texttt{longest\_common\_subsequence} --- extended stdlib batch 3
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest\_common\_subsequence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest\_common\_subsequence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest\_common\_substring}}{longest\_common\_substring}}\label{longest_common_substring}

\texttt{longest\_common\_substring} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest\_common\_substring $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest\_common\_substring |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest\_decreasing}}{longest\_decreasing}}\label{longest_decreasing}

\texttt{longest\_decreasing} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest\_decreasing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest\_decreasing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest\_increasing}}{longest\_increasing}}\label{longest_increasing}

\texttt{longest\_increasing} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest\_increasing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest\_increasing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{longest\_run}}{longest\_run}}\label{longest_run}

\texttt{longest\_run} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = longest\_run $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map longest\_run |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{look\_and\_say}}{look\_and\_say}}\label{look_and_say}

\texttt{look\_and\_say} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = look\_and\_say $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map look\_and\_say |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lookback\_call}}{lookback\_call}}\label{lookback_call}

\texttt{lookback\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lookback\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lookback\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lookback\_time}}{lookback\_time}}\label{lookback_time}

\texttt{lookback\_time} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lookback\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lookback\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lookup\_assoc}}{lookup\_assoc}}\label{lookup_assoc}

\texttt{lookup\_assoc} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lookup\_assoc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lookup\_assoc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lorentz}}{lorentz}}\label{lorentz}

\texttt{lorentz\_factor(\$velocity)} (alias \texttt{lorentz}) ---
relativistic gamma factor γ = 1/√(1-v²/c²). Returns infinity at v ≥ c.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lorentz(0)           \# 1 (at rest)}
\NormalTok{p lorentz(0.9 * 3e8)   \# \textasciitilde{}2.29 (at 90\% speed of light)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lorentz\_factor\_v}}{lorentz\_factor\_v}}\label{lorentz_factor_v}

\texttt{lorentz\_factor\_v} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lorentz\_factor\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lorentz\_factor\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lorentz\_force\_mag}}{lorentz\_force\_mag}}\label{lorentz_force_mag}

\texttt{lorentz\_force\_mag} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lorentz\_force\_mag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lorentz\_force\_mag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lorentz\_gamma}}{lorentz\_gamma}}\label{lorentz_gamma}

\texttt{lorentz\_gamma} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lorentz\_gamma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lorentz\_gamma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lorenz}}{lorenz}}\label{lorenz}

\texttt{lorenz\_curve(@data)} (alias \texttt{lorenz}) --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $curve = lorenz(10, 20, 30, 40)}
\NormalTok{for my $pt (@$curve) \{}
\NormalTok{    p "$pt{-}\textgreater{}[0], $pt{-}\textgreater{}[1]"}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lose\_lose}}{lose\_lose}}\label{lose_lose}

\texttt{lose\_lose} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lose\_lose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lose\_lose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{loss\_frequency\_poisson}}{loss\_frequency\_poisson}}\label{loss_frequency_poisson}

\texttt{loss\_frequency\_poisson} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = loss\_frequency\_poisson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map loss\_frequency\_poisson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{loss\_severity\_lognormal}}{loss\_severity\_lognormal}}\label{loss_severity_lognormal}

\texttt{loss\_severity\_lognormal} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = loss\_severity\_lognormal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map loss\_severity\_lognormal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lotka\_volterra\_step}}{lotka\_volterra\_step}}\label{lotka_volterra_step}

\texttt{lotka\_volterra\_step} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lotka\_volterra\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lotka\_volterra\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{louvain\_gain}}{louvain\_gain}}\label{louvain_gain}

\texttt{louvain\_gain} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = louvain\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map louvain\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lower\_bound}}{lower\_bound}}\label{lower_bound}

\texttt{lower\_bound} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lower\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lower\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lower\_triangular\_q}}{lower\_triangular\_q}}\label{lower_triangular_q}

\texttt{lower\_triangular\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lower\_triangular\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lower\_triangular\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lowercase}}{lowercase}}\label{lowercase}

\texttt{lowercase} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lowercase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lowercase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lowpass\_filter}}{lowpass\_filter}}\label{lowpass_filter}

\texttt{lowpass\_filter(\textbackslash{}@signal,\ \$cutoff)} (alias
\texttt{lpf}) --- applies a simple low-pass filter to remove
high-frequency components. Cutoff is normalized (0-1). Uses exponential
moving average.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @noisy = map \{ sin(\_/10) + rand(0.2) \} 1:100}
\NormalTok{my $smooth = lpf(\textbackslash{}@noisy, 0.1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lp\_norm}}{lp\_norm}}\label{lp_norm}

\texttt{lp\_norm} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lp\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lp\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lp\_relax\_round}}{lp\_relax\_round}}\label{lp_relax_round}

\texttt{lp\_relax\_round} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lp\_relax\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lp\_relax\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lpad}}{lpad}}\label{lpad}

\texttt{lpad} --- trivial string ops builtin. Alias for
\texttt{pad\_left}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lpad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lpad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lplanck}}{lplanck}}\label{lplanck}

\texttt{planck\_length} (alias \texttt{lplanck}) --- lP ≈ 1.616×10⁻³⁵ m.
Smallest meaningful length in quantum mechanics.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p lplanck   \# 1.616255e{-}35 m}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lpt}}{lpt}}\label{lpt}

\texttt{lpt} --- batch 10 builtin. Alias for \texttt{lpt\_schedule}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lpt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lpt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lpt\_schedule}}{lpt\_schedule}}\label{lpt_schedule}

\texttt{lpt\_schedule} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lpt\_schedule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lpt\_schedule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lpush}}{lpush}}\label{lpush}

\texttt{lpush} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lpush $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lpush |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lqg\_step}}{lqg\_step}}\label{lqg_step}

\texttt{lqg\_step} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lqg\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lqg\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lqr\_gain\_continuous}}{lqr\_gain\_continuous}}\label{lqr_gain_continuous}

\texttt{lqr\_gain\_continuous} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lqr\_gain\_continuous $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lqr\_gain\_continuous |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lqr\_gain\_discrete}}{lqr\_gain\_discrete}}\label{lqr_gain_discrete}

\texttt{lqr\_gain\_discrete} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lqr\_gain\_discrete $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lqr\_gain\_discrete |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lr0\_items\_step}}{lr0\_items\_step}}\label{lr0_items_step}

\texttt{lr0\_items\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lr0\_items\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lr0\_items\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lr1\_canonical\_collection}}{lr1\_canonical\_collection}}\label{lr1_canonical_collection}

\texttt{lr1\_canonical\_collection} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lr1\_canonical\_collection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lr1\_canonical\_collection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lrange}}{lrange}}\label{lrange}

\texttt{lrange} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lrange $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lrange |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lrem}}{lrem}}\label{lrem}

\texttt{lrem} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lrem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lrem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lru\_new}}{lru\_new}}\label{lru_new}

\texttt{lru\_new} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lru\_new $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lru\_new |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lrun}}{lrun}}\label{lrun}

\texttt{lrun} --- extended stdlib batch 3 builtin. Alias for
\texttt{longest\_run}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lrun $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lrun |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lse}}{lse}}\label{lse}

\texttt{lse} --- batch 11 builtin. Alias for \texttt{log\_sum\_exp}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lsearch}}{lsearch}}\label{lsearch}

\texttt{lsearch} --- collection (batch 2) builtin. Alias for
\texttt{linear\_search}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lsearch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lsearch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lsp\_completion\_words}}{lsp\_completion\_words}}\label{lsp_completion_words}

\texttt{lsp\_completion\_words} (alias \texttt{lsp\_words}) --- emits
every name LSP tab-complete should know about, sorted ASCII. Three
sources merged: (1) every callable bare-name spelling from
\texttt{\%all} (\textasciitilde9k names, primaries + aliases), (2)
sigil-prefixed live bindings (\texttt{\%a}, \texttt{\%all},
\texttt{\%b}, \texttt{\%parameters}, \texttt{@ARGV}, \texttt{@INC},
\texttt{@fpath}, \texttt{@path}, \texttt{\$\_},
\texttt{\$stryke::VERSION}, \ldots), (3) \texttt{CORE::}/\texttt{main::}
qualified spellings of every callable / unqualified binding, plus stryke
language keywords (\texttt{fn}, \texttt{match}, \texttt{class},
\texttt{struct}, \texttt{enum}, \texttt{mysync}, \texttt{frozen},
\ldots). Drives the canonical
\texttt{strykelang/lsp\_completion\_words.txt} snapshot consumed by both
the static analyzer (linter) and LSP completion provider.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{lsp\_words |\textgreater{} ep                                              \# browse everything}
\NormalTok{p len(lsp\_words)                                              \# \textasciitilde{}18,000 entries}
\NormalTok{\# Regenerate the on{-}disk snapshot:}
\NormalTok{\# stryke {-}e \textquotesingle{}lsp\_words |\textgreater{} ep\textquotesingle{} \textgreater{} strykelang/lsp\_completion\_words.txt}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lst\_to\_solar}}{lst\_to\_solar}}\label{lst_to_solar}

\texttt{lst\_to\_solar} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lst\_to\_solar $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lstat}}{lstat}}\label{lstat}

\texttt{lstat} --- filesystem builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lstat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lstat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lucas}}{lucas}}\label{lucas}

\texttt{lucas} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lucas $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lucas |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{luhn}}{luhn}}\label{luhn}

\texttt{luhn} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{luhn\_check}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = luhn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map luhn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{luhn\_check}}{luhn\_check}}\label{luhn_check}

\texttt{luhn\_check} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = luhn\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map luhn\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{luminance\_relative}}{luminance\_relative}}\label{luminance_relative}

\texttt{luminance\_relative} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = luminance\_relative $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map luminance\_relative |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lunation\_index}}{lunation\_index}}\label{lunation_index}

\texttt{lunation\_index} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lunation\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lunation\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lv\_competition\_step}}{lv\_competition\_step}}\label{lv_competition_step}

\texttt{lv\_competition\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lv\_competition\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lv\_competition\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ly\_to\_pc}}{ly\_to\_pc}}\label{ly_to_pc}

\texttt{ly\_to\_pc} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ly\_to\_pc $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lyndon\_factorize}}{lyndon\_factorize}}\label{lyndon_factorize}

\texttt{lyndon\_factorize} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lyndon\_factorize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lyndon\_factorize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz}}{lz}}\label{lz}

\texttt{lz} --- base conversion builtin. Alias for
\texttt{leading\_zeros}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz4\_block\_step}}{lz4\_block\_step}}\label{lz4_block_step}

\texttt{lz4\_block\_step} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lz4\_block\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lz4\_block\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz4\_encode\_block}}{lz4\_encode\_block}}\label{lz4_encode_block}

\texttt{lz4\_encode\_block} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lz4\_encode\_block $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lz4\_encode\_block |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz4\_match\_offset}}{lz4\_match\_offset}}\label{lz4_match_offset}

\texttt{lz4\_match\_offset} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lz4\_match\_offset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lz4\_match\_offset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz77\_match\_length}}{lz77\_match\_length}}\label{lz77_match_length}

\texttt{lz77\_match\_length} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lz77\_match\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lz77\_match\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lz78\_dictionary\_growth}}{lz78\_dictionary\_growth}}\label{lz78_dictionary_growth}

\texttt{lz78\_dictionary\_growth} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lz78\_dictionary\_growth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lz78\_dictionary\_growth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzma\_encode\_step}}{lzma\_encode\_step}}\label{lzma_encode_step}

\texttt{lzma\_encode\_step} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lzma\_encode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lzma\_encode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzma\_range\_step}}{lzma\_range\_step}}\label{lzma_range_step}

\texttt{lzma\_range\_step} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lzma\_range\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lzma\_range\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzo\_encode\_step}}{lzo\_encode\_step}}\label{lzo_encode_step}

\texttt{lzo\_encode\_step} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lzo\_encode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lzo\_encode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzw\_encode}}{lzw\_encode}}\label{lzw_encode}

\texttt{lzw\_encode} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lzw\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lzw\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{lzw\_step\_dict}}{lzw\_step\_dict}}\label{lzw_step_dict}

\texttt{lzw\_step\_dict} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = lzw\_step\_dict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map lzw\_step\_dict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{m5}}{m5}}\label{m5}

\texttt{m5} --- crypto / encoding builtin. Alias for \texttt{md5}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = m5 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map m5 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{m\_to\_feet}}{m\_to\_feet}}\label{m_to_feet}

\texttt{m\_to\_feet} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = m\_to\_feet $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{m\_to\_miles}}{m\_to\_miles}}\label{m_to_miles}

\texttt{m\_to\_miles} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = m\_to\_miles $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{m\_to\_s}}{m\_to\_s}}\label{m_to_s}

\texttt{m\_to\_s} --- unit conversions builtin. Alias for
\texttt{minutes\_to\_seconds}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = m\_to\_s $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{m\_to\_yards}}{m\_to\_yards}}\label{m_to_yards}

\texttt{m\_to\_yards} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = m\_to\_yards $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ma\_model\_likelihood}}{ma\_model\_likelihood}}\label{ma_model_likelihood}

\texttt{ma\_model\_likelihood} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ma\_model\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ma\_model\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mac\_duration}}{mac\_duration}}\label{mac_duration}

\texttt{bond\_duration} (alias \texttt{mac\_duration}) computes Macaulay
duration --- the weighted-average time to receive cash flows.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $dur = bond\_duration([5,5,5,105], 0.05)  \# ≈ 3.72 years}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{macarthur\_wilson\_extinction}}{macarthur\_wilson\_extinction}}\label{macarthur_wilson_extinction}

\texttt{macarthur\_wilson\_extinction} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = macarthur\_wilson\_extinction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map macarthur\_wilson\_extinction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{macarthur\_wilson\_immigration}}{macarthur\_wilson\_immigration}}\label{macarthur_wilson_immigration}

\texttt{macarthur\_wilson\_immigration} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = macarthur\_wilson\_immigration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map macarthur\_wilson\_immigration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{macaulay\_duration}}{macaulay\_duration}}\label{macaulay_duration}

\texttt{macaulay\_duration} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = macaulay\_duration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map macaulay\_duration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{macauley\_duration}}{macauley\_duration}}\label{macauley_duration}

\texttt{macauley\_duration} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = macauley\_duration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map macauley\_duration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{macdur}}{macdur}}\label{macdur}

\texttt{macdur} --- finance (extended) builtin. Alias for
\texttt{duration}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = macdur $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map macdur |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mach\_full\_step}}{mach\_full\_step}}\label{mach_full_step}

\texttt{mach\_full\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mach\_full\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mach\_full\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mad}}{mad}}\label{mad}

\texttt{mad} --- math / numeric (uncategorized batch) builtin. Alias for
\texttt{median\_absolute\_deviation}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{madd}}{madd}}\label{madd}

\texttt{madd} --- extended stdlib builtin. Alias for
\texttt{matrix\_add}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = madd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map madd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mae}}{mae}}\label{mae}

\texttt{mae} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mae $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mae |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mag}}{mag}}\label{mag}

\texttt{mag} --- extended stdlib builtin. Alias for \texttt{magnitude}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{magenta}}{magenta}}\label{magenta}

\texttt{magenta} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = magenta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map magenta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{magenta\_bold}}{magenta\_bold}}\label{magenta_bold}

\texttt{magenta\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = magenta\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map magenta\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maglens}}{maglens}}\label{maglens}

\texttt{maglens} --- physics formulas builtin. Alias for
\texttt{magnification\_lens}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maglens $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maglens |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{magnification\_lens}}{magnification\_lens}}\label{magnification_lens}

\texttt{magnification\_lens} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = magnification\_lens $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map magnification\_lens |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{magnitude}}{magnitude}}\label{magnitude}

\texttt{magnitude} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = magnitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map magnitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{magnus\_1st}}{magnus\_1st}}\label{magnus_1st}

\texttt{magnus\_1st} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = magnus\_1st $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map magnus\_1st |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mahal}}{mahal}}\label{mahal}

\texttt{mahalanobis} --- Mahalanobis distance. Args: data, center,
inverse\_covariance. Like R\textquotesingle s mahalanobis().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @d = @\{mahal([[1,2],[3,4]], [2,3], [[1,0],[0,1]])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mahalanobis\_1d}}{mahalanobis\_1d}}\label{mahalanobis_1d}

\texttt{mahalanobis\_1d} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mahalanobis\_1d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mahalanobis\_1d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{main}}{main}}\label{main}

\texttt{main::} --- the default package every script starts in.
\texttt{our} variables and \texttt{fn} declarations without an explicit
\texttt{package} directive land in \texttt{main::}; bare references like
\texttt{\$x} / \texttt{@a} / \texttt{\%h} resolve to \texttt{\$main::x}
/ \texttt{@main::a} / \texttt{\%main::h} when looked up via the symbol
table.

Use \texttt{main::} qualifier when you need to disambiguate inside a
nested package, or when introspecting a script from a library context.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{our $verbose = 1}
\NormalTok{p $main::verbose                              \# 1 — same scalar}

\NormalTok{\# Inside a class, the bare name resolves to the class — main:: gets you out:}
\NormalTok{class Foo \{}
\NormalTok{    fn check \{ p $main::verbose \}            \# reads top{-}level our}
\NormalTok{\}}

\NormalTok{\# \%main:: is the symbol{-}table stash. Lists every name declared}
\NormalTok{\# at the top level (subs, our, our @, our \%).}
\NormalTok{p scalar keys \%main::                         \# symbol{-}table size}
\NormalTok{keys \%main:: |\textgreater{} sort |\textgreater{} p                    \# browse every top{-}level name}
\end{Highlighting}
\end{Shaded}

Related namespaces: \texttt{CORE::} (every builtin), \texttt{stryke::}
(reflection hashes --- \texttt{\%stryke::builtins} etc.), and
\texttt{Pkg::} for any user-declared \texttt{package\ Pkg}.

\section{\texorpdfstring{\texttt{main\_sequence\_lifetime}}{main\_sequence\_lifetime}}\label{main_sequence_lifetime}

\texttt{main\_sequence\_lifetime} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = main\_sequence\_lifetime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map main\_sequence\_lifetime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mainardi\_codazzi\_step}}{mainardi\_codazzi\_step}}\label{mainardi_codazzi_step}

\texttt{mainardi\_codazzi\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mainardi\_codazzi\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mainardi\_codazzi\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{majority}}{majority}}\label{majority}

\texttt{majority} --- extended stdlib batch 3 builtin. Alias for
\texttt{majority\_element}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = majority $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map majority |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{majority\_element}}{majority\_element}}\label{majority_element}

\texttt{majority\_element} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = majority\_element $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map majority\_element |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mall}}{mall}}\label{mall}

\texttt{mall} --- extended stdlib builtin. Alias for
\texttt{match\_all}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mall $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mall |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mallat\_pyramid\_step}}{mallat\_pyramid\_step}}\label{mallat_pyramid_step}

\texttt{mallat\_pyramid\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mallat\_pyramid\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mallat\_pyramid\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{manacher}}{manacher}}\label{manacher}

\texttt{manacher} --- batch 10 builtin. Alias for
\texttt{manacher\_radii}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = manacher $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map manacher |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{manacher\_radii}}{manacher\_radii}}\label{manacher_radii}

\texttt{manacher\_radii} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = manacher\_radii $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map manacher\_radii |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mandel}}{mandel}}\label{mandel}

\texttt{mandel} --- algorithms / puzzles builtin. Alias for
\texttt{mandelbrot\_char}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mandel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mandel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mandel\_q}}{mandel\_q}}\label{mandel_q}

\texttt{mandel\_q} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mandel\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mandel\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mandelbrot\_char}}{mandelbrot\_char}}\label{mandelbrot_char}

\texttt{mandelbrot\_char} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mandelbrot\_char $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mandelbrot\_char |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{manhattan\_distance}}{manhattan\_distance}}\label{manhattan_distance}

\texttt{manhattan\_distance} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = manhattan\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map manhattan\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{manipulability\_yoshikawa}}{manipulability\_yoshikawa}}\label{manipulability_yoshikawa}

\texttt{manipulability\_yoshikawa} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = manipulability\_yoshikawa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map manipulability\_yoshikawa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mann\_kendall\_tau}}{mann\_kendall\_tau}}\label{mann_kendall_tau}

\texttt{mann\_kendall\_tau} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mann\_kendall\_tau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mann\_kendall\_tau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mann\_whitney}}{mann\_whitney}}\label{mann_whitney}

\texttt{wilcox\_test} (aliases \texttt{wilcox}, \texttt{mann\_whitney})
--- Wilcoxon rank-sum test (Mann-Whitney U). Returns U statistic. Like
R\textquotesingle s wilcox.test().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $U = wilcox([1,2,3], [4,5,6])  \# 0 (no overlap)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{manning\_velocity}}{manning\_velocity}}\label{manning_velocity}

\texttt{manning\_velocity} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = manning\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map manning\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mannwhitneyu}}{mannwhitneyu}}\label{mannwhitneyu}

\texttt{mannwhitneyu} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mannwhitneyu $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mannwhitneyu |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_bp}}{map\_bp}}\label{map_bp}

\texttt{map\_bp} --- batch 12 builtin. Alias for
\texttt{mean\_arterial\_pressure}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = map\_bp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map map\_bp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_chars}}{map\_chars}}\label{map_chars}

\texttt{map\_chars} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = map\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map map\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_indexed}}{map\_indexed}}\label{map_indexed}

\texttt{map\_indexed} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = map\_indexed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map map\_indexed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_keys\_fn}}{map\_keys\_fn}}\label{map_keys_fn}

\texttt{map\_keys\_fn} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = map\_keys\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map map\_keys\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_range}}{map\_range}}\label{map_range}

\texttt{map\_range(\$value,\ \$in\_min,\ \$in\_max,\ \$out\_min,\ \$out\_max)}
(alias \texttt{remap}) --- remap a value from one range to another.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p remap(50, 0, 100, 0, 1)     \# 0.5}
\NormalTok{p remap(75, 0, 100, 0, 255)   \# 191.25 (percent to byte)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_values\_fn}}{map\_values\_fn}}\label{map_values_fn}

\texttt{map\_values\_fn} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = map\_values\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map map\_values\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{map\_while}}{map\_while}}\label{map_while}

\texttt{map\_while} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = map\_while $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map map\_while |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mapcat}}{mapcat}}\label{mapcat}

\texttt{mapcat} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mapcat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mapcat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mapi}}{mapi}}\label{mapi}

\texttt{mapi} --- go/general functional utilities builtin. Alias for
\texttt{map\_indexed}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mapi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mapi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mapping\_class\_torus}}{mapping\_class\_torus}}\label{mapping_class_torus}

\texttt{mapping\_class\_torus} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mapping\_class\_torus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mapping\_class\_torus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mapw}}{mapw}}\label{mapw}

\texttt{mapw} --- rust iterator methods builtin. Alias for
\texttt{map\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mapw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mapw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{marcum\_q}}{marcum\_q}}\label{marcum_q}

\texttt{marcum\_q} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = marcum\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map marcum\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{margalef\_richness}}{margalef\_richness}}\label{margalef_richness}

\texttt{margalef\_richness} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = margalef\_richness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map margalef\_richness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{margin}}{margin}}\label{margin}

\texttt{margin} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = margin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map margin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{margin\_price}}{margin\_price}}\label{margin_price}

\texttt{margin\_price} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = margin\_price $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map margin\_price |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{margrabe}}{margrabe}}\label{margrabe}

\texttt{margrabe} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = margrabe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map margrabe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{markov\_decision\_value}}{markov\_decision\_value}}\label{markov_decision_value}

\texttt{markov\_decision\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = markov\_decision\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map markov\_decision\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{markov\_switching\_ar}}{markov\_switching\_ar}}\label{markov_switching_ar}

\texttt{markov\_switching\_ar} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = markov\_switching\_ar $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map markov\_switching\_ar |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{markov\_switching\_mr}}{markov\_switching\_mr}}\label{markov_switching_mr}

\texttt{markov\_switching\_mr} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = markov\_switching\_mr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map markov\_switching\_mr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{markup}}{markup}}\label{markup}

\texttt{markup} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = markup $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map markup |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{markup\_price}}{markup\_price}}\label{markup_price}

\texttt{markup\_price} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = markup\_price $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map markup\_price |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{marshallian\_demand}}{marshallian\_demand}}\label{marshallian_demand}

\texttt{marshallian\_demand} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = marshallian\_demand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map marshallian\_demand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mask}}{mask}}\label{mask}

\texttt{mask} --- string processing (uncategorized batch) builtin. Alias
for \texttt{mask\_string}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mask $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mask |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mask\_string}}{mask\_string}}\label{mask_string}

\texttt{mask\_string} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mask\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mask\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mass\_transport\_overpotential}}{mass\_transport\_overpotential}}\label{mass_transport_overpotential}

\texttt{mass\_transport\_overpotential} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mass\_transport\_overpotential $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mass\_transport\_overpotential |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mat\_mul}}{mat\_mul}}\label{mat_mul}

\texttt{mat\_mul} --- matrix / linear algebra builtin. Alias for
\texttt{matrix\_multiply}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mat\_mul $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mat\_mul |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mat\_scale}}{mat\_scale}}\label{mat_scale}

\texttt{mat\_scale} --- extended stdlib builtin. Alias for
\texttt{matrix\_scale}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mat\_scale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mat\_scale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{match\_all}}{match\_all}}\label{match_all}

\texttt{match\_all} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = match\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map match\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{match\_rating\_codex}}{match\_rating\_codex}}\label{match_rating_codex}

\texttt{match\_rating\_codex} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = match\_rating\_codex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map match\_rating\_codex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matches\_regex}}{matches\_regex}}\label{matches_regex}

\texttt{matches\_regex} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matches\_regex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matches\_regex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matching\_market\_step}}{matching\_market\_step}}\label{matching_market_step}

\texttt{matching\_market\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matching\_market\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matching\_market\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matching\_pennies\_payoff}}{matching\_pennies\_payoff}}\label{matching_pennies_payoff}

\texttt{matching\_pennies\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matching\_pennies\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matching\_pennies\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mathieu\_b}}{mathieu\_b}}\label{mathieu_b}

\texttt{mathieu\_b} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mathieu\_b $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mathieu\_b |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mathieu\_ce0}}{mathieu\_ce0}}\label{mathieu_ce0}

\texttt{mathieu\_ce0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mathieu\_ce0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mathieu\_ce0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mathieu\_se1}}{mathieu\_se1}}\label{mathieu_se1}

\texttt{mathieu\_se1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mathieu\_se1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mathieu\_se1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matmul}}{matmul}}\label{matmul}

\texttt{matmul} --- extended stdlib builtin. Alias for
\texttt{matrix\_mul}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matmul $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matmul |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_add}}{matrix\_add}}\label{matrix_add}

\texttt{matrix\_add} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_add $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_add |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_anti\_diagonal}}{matrix\_anti\_diagonal}}\label{matrix_anti_diagonal}

\texttt{matrix\_anti\_diagonal} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_anti\_diagonal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_anti\_diagonal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_col}}{matrix\_col}}\label{matrix_col}

\texttt{matrix\_col} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_col $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_col |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_det}}{matrix\_det}}\label{matrix_det}

\texttt{matrix\_det} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_det $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_det |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_diag}}{matrix\_diag}}\label{matrix_diag}

\texttt{matrix\_diag} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_diag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_diag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_diagonal}}{matrix\_diagonal}}\label{matrix_diagonal}

\texttt{matrix\_diagonal} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_diagonal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_diagonal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_flatten}}{matrix\_flatten}}\label{matrix_flatten}

\texttt{matrix\_flatten} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_flatten $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_flatten |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_from\_rows}}{matrix\_from\_rows}}\label{matrix_from_rows}

\texttt{matrix\_from\_rows} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_from\_rows $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_from\_rows |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_hadamard}}{matrix\_hadamard}}\label{matrix_hadamard}

\texttt{matrix\_hadamard} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_hadamard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_hadamard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_identity}}{matrix\_identity}}\label{matrix_identity}

\texttt{matrix\_identity} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_identity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_identity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_identity\_q}}{matrix\_identity\_q}}\label{matrix_identity_q}

\texttt{matrix\_identity\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_identity\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_identity\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_inverse}}{matrix\_inverse}}\label{matrix_inverse}

\texttt{matrix\_inverse} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_inverse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_inverse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_lu}}{matrix\_lu}}\label{matrix_lu}

\texttt{matrix\_lu} (alias \texttt{mlu}) computes the LU decomposition
with partial pivoting. Returns {[}L, U, P{]} where PA = LU.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($L, $U, $P) = @\{mlu([[4,3],[6,3]])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_map}}{matrix\_map}}\label{matrix_map}

\texttt{matrix\_map} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_map $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_map |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_max}}{matrix\_max}}\label{matrix_max}

\texttt{matrix\_max} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_min}}{matrix\_min}}\label{matrix_min}

\texttt{matrix\_min} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_min $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_min |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_mul}}{matrix\_mul}}\label{matrix_mul}

\texttt{matrix\_mul} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_mul $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_mul |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_mult}}{matrix\_mult}}\label{matrix_mult}

\texttt{matrix\_mult} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_mult $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_mult |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_multiply}}{matrix\_multiply}}\label{matrix_multiply}

\texttt{matrix\_multiply} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_multiply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_multiply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_norm}}{matrix\_norm}}\label{matrix_norm}

\texttt{matrix\_norm} (alias \texttt{mnorm}) computes a matrix norm.
Default is Frobenius; pass 1 for max-column-sum, Inf for max-row-sum.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mnorm([[3,4]])           \# 5 (Frobenius)}
\NormalTok{p mnorm([[1,2],[3,4]], 1)  \# 6 (1{-}norm)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_ones}}{matrix\_ones}}\label{matrix_ones}

\texttt{matrix\_ones} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_ones $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_ones |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_orthogonal\_q}}{matrix\_orthogonal\_q}}\label{matrix_orthogonal_q}

\texttt{matrix\_orthogonal\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_orthogonal\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_orthogonal\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_pinv}}{matrix\_pinv}}\label{matrix_pinv}

\texttt{matrix\_pinv} (aliases \texttt{mpinv}, \texttt{pinv}) computes
the Moore-Penrose pseudo-inverse via (A\^{}T A)\^{}\{-1\} A\^{}T.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $A\_plus = pinv([[1,2],[3,4],[5,6]])}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_power}}{matrix\_power}}\label{matrix_power}

\texttt{matrix\_power} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_qr}}{matrix\_qr}}\label{matrix_qr}

\texttt{matrix\_qr} (alias \texttt{mqr}) computes the QR decomposition
via Gram-Schmidt orthogonalization. Returns {[}Q, R{]} where A = QR.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($Q, $R) = @\{mqr([[1,1],[1,{-}1]])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_random\_normal}}{matrix\_random\_normal}}\label{matrix_random_normal}

\texttt{matrix\_random\_normal} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_random\_normal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_random\_normal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_random\_uniform}}{matrix\_random\_uniform}}\label{matrix_random_uniform}

\texttt{matrix\_random\_uniform} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_random\_uniform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_random\_uniform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_row}}{matrix\_row}}\label{matrix_row}

\texttt{matrix\_row} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_row $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_row |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_scalar}}{matrix\_scalar}}\label{matrix_scalar}

\texttt{matrix\_scalar} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_scalar $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_scalar |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_scale}}{matrix\_scale}}\label{matrix_scale}

\texttt{matrix\_scale} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_scale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_scale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_shape}}{matrix\_shape}}\label{matrix_shape}

\texttt{matrix\_shape} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_shape $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_shape |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_solve}}{matrix\_solve}}\label{matrix_solve}

\texttt{matrix\_solve} (aliases \texttt{msolve}, \texttt{solve}) solves
the linear system Ax=b via Gaussian elimination with partial pivoting.
Returns the solution vector x.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $A = [[2,1],[{-}1,1]]}
\NormalTok{my $b = [5,2]}
\NormalTok{my $x = solve($A, $b)   \# [1, 3]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_sub}}{matrix\_sub}}\label{matrix_sub}

\texttt{matrix\_sub} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_sub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_sub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_sum}}{matrix\_sum}}\label{matrix_sum}

\texttt{matrix\_sum} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_symmetric\_q}}{matrix\_symmetric\_q}}\label{matrix_symmetric_q}

\texttt{matrix\_symmetric\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_symmetric\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_symmetric\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_trace}}{matrix\_trace}}\label{matrix_trace}

\texttt{matrix\_trace} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_trace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_trace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_transpose}}{matrix\_transpose}}\label{matrix_transpose}

\texttt{matrix\_transpose} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_transpose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_transpose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_zero\_q}}{matrix\_zero\_q}}\label{matrix_zero_q}

\texttt{matrix\_zero\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_zero\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_zero\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matrix\_zeros}}{matrix\_zeros}}\label{matrix_zeros}

\texttt{matrix\_zeros} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matrix\_zeros $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matrix\_zeros |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matroid\_greedy\_step}}{matroid\_greedy\_step}}\label{matroid_greedy_step}

\texttt{matroid\_greedy\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matroid\_greedy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matroid\_greedy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{matroid\_intersection\_step}}{matroid\_intersection\_step}}\label{matroid_intersection_step}

\texttt{matroid\_intersection\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = matroid\_intersection\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map matroid\_intersection\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max2}}{max2}}\label{max2}

\texttt{max2} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_abs}}{max\_abs}}\label{max_abs}

\texttt{max\_abs} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_abs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_abs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_by}}{max\_by}}\label{max_by}

\texttt{max\_by} --- functional / iterator builtin. Alias for
\texttt{take\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_degree}}{max\_degree}}\label{max_degree}

\texttt{max\_degree} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_degree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_degree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_drawdown}}{max\_drawdown}}\label{max_drawdown}

\texttt{max\_drawdown(@equity\_curve)} (alias \texttt{mdd}) --- computes
the maximum peak-to-trough decline in a series of values. Returns as a
decimal (0.2 = 20\% drawdown). Key risk metric.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @equity = (100, 120, 90, 110, 85, 130)}
\NormalTok{p mdd(@equity)   \# \textasciitilde{}0.29 (29\% max drawdown)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_drawdown\_arr}}{max\_drawdown\_arr}}\label{max_drawdown_arr}

\texttt{max\_drawdown\_arr} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_drawdown\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_drawdown\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_float}}{max\_float}}\label{max_float}

\texttt{max\_float} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_float $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_float |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_flow\_ek}}{max\_flow\_ek}}\label{max_flow_ek}

\texttt{max\_flow\_ek} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_flow\_ek $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_flow\_ek |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_flow\_ford\_fulkerson\_step}}{max\_flow\_ford\_fulkerson\_step}}\label{max_flow_ford_fulkerson_step}

\texttt{max\_flow\_ford\_fulkerson\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_flow\_ford\_fulkerson\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_flow\_ford\_fulkerson\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_heart\_rate}}{max\_heart\_rate}}\label{max_heart_rate}

\texttt{max\_heart\_rate} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_heart\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_heart\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_independent\_set}}{max\_independent\_set}}\label{max_independent_set}

\texttt{max\_independent\_set} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_independent\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_independent\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_list}}{max\_list}}\label{max_list}

\texttt{max\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_norm}}{max\_norm}}\label{max_norm}

\texttt{max\_norm} --- batch 11 builtin. Alias for \texttt{linf\_norm}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_of}}{max\_of}}\label{max_of}

\texttt{max\_of} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{max\_sum\_subarray}}{max\_sum\_subarray}}\label{max_sum_subarray}

\texttt{max\_sum\_subarray} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = max\_sum\_subarray $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map max\_sum\_subarray |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maxby}}{maxby}}\label{maxby}

\texttt{maxby} --- additional missing stdlib functions builtin. Alias
for \texttt{maximum\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maxby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maxby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maxdd}}{maxdd}}\label{maxdd}

\texttt{maxdd} --- finance (extended) builtin. Alias for
\texttt{max\_drawdown}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maxdd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maxdd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maximin\_share}}{maximin\_share}}\label{maximin_share}

\texttt{maximin\_share} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maximin\_share $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maximin\_share |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maximum\_bipartite\_matching}}{maximum\_bipartite\_matching}}\label{maximum_bipartite_matching}

\texttt{maximum\_bipartite\_matching} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maximum\_bipartite\_matching $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maximum\_bipartite\_matching |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maximum\_by}}{maximum\_by}}\label{maximum_by}

\texttt{maximum\_by} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maximum\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maximum\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maxstr}}{maxstr}}\label{maxstr}

\texttt{maxstr} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maxstr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maxstr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maxsub}}{maxsub}}\label{maxsub}

\texttt{maxsub} --- extended stdlib batch 3 builtin. Alias for
\texttt{max\_sum\_subarray}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maxsub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maxsub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{maya\_long\_count\_from\_fixed}}{maya\_long\_count\_from\_fixed}}\label{maya_long_count_from_fixed}

\texttt{maya\_long\_count\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = maya\_long\_count\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map maya\_long\_count\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mayan\_haab\_from\_fixed}}{mayan\_haab\_from\_fixed}}\label{mayan_haab_from_fixed}

\texttt{mayan\_haab\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mayan\_haab\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mayan\_haab\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mayan\_tzolkin\_from\_fixed}}{mayan\_tzolkin\_from\_fixed}}\label{mayan_tzolkin_from_fixed}

\texttt{mayan\_tzolkin\_from\_fixed} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mayan\_tzolkin\_from\_fixed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mayan\_tzolkin\_from\_fixed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mb\_to\_bytes}}{mb\_to\_bytes}}\label{mb_to_bytes}

\texttt{mb\_to\_bytes} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mb\_to\_bytes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mb\_to\_gb}}{mb\_to\_gb}}\label{mb_to_gb}

\texttt{mb\_to\_gb} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mb\_to\_gb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mc\_limiter}}{mc\_limiter}}\label{mc_limiter}

\texttt{mc\_limiter} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mc\_limiter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mc\_limiter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcat}}{mcat}}\label{mcat}

\texttt{mcat} --- algebraic match builtin. Alias for \texttt{mapcat}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcc}}{mcc}}\label{mcc}

\texttt{mcc} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcol}}{mcol}}\label{mcol}

\texttt{mcol} --- extended stdlib builtin. Alias for
\texttt{matrix\_col}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mcol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mcol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mcp\_serve\_registered\_tools}}{mcp\_serve\_registered\_tools}}\label{mcp_serve_registered_tools}

\texttt{mcp\_serve\_registered\_tools("server-name")} --- convert every
tool registered via \texttt{tool\ fn} / \texttt{ai\_register\_tool} into
MCP server schema and run the stdio JSON-RPC loop. Used by
\texttt{stryke\ build\ -\/-mcp-server}.

\section{\texorpdfstring{\texttt{md5}}{md5}}\label{md5}

\texttt{md5} --- crypto / encoding builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = md5 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map md5 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mdet}}{mdet}}\label{mdet}

\texttt{mdet} --- extended stdlib builtin. Alias for
\texttt{matrix\_det}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mdet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mdet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mdiag}}{mdiag}}\label{mdiag}

\texttt{mdiag} --- extended stdlib builtin. Alias for
\texttt{matrix\_diag}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mdiag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mdiag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mdiagvec}}{mdiagvec}}\label{mdiagvec}

\texttt{mdiagvec} --- batch 11 builtin. Alias for
\texttt{matrix\_diagonal}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mdiagvec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mdiagvec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mdist}}{mdist}}\label{mdist}

\texttt{mdist} --- extended stdlib builtin. Alias for
\texttt{manhattan\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mduration}}{mduration}}\label{mduration}

\texttt{mduration} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mduration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mduration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_absolute\_error}}{mean\_absolute\_error}}\label{mean_absolute_error}

\texttt{mean\_absolute\_error} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_absolute\_error $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_absolute\_error |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_activity\_coeff\_pitzer}}{mean\_activity\_coeff\_pitzer}}\label{mean_activity_coeff_pitzer}

\texttt{mean\_activity\_coeff\_pitzer} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_activity\_coeff\_pitzer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_activity\_coeff\_pitzer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_arterial\_pressure}}{mean\_arterial\_pressure}}\label{mean_arterial_pressure}

\texttt{mean\_arterial\_pressure} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_arterial\_pressure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_arterial\_pressure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_curvature\_step}}{mean\_curvature\_step}}\label{mean_curvature_step}

\texttt{mean\_curvature\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_curvature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_curvature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_filter\_window}}{mean\_filter\_window}}\label{mean_filter_window}

\texttt{mean\_filter\_window} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_filter\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_filter\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_list}}{mean\_list}}\label{mean_list}

\texttt{mean\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_solar\_anomaly}}{mean\_solar\_anomaly}}\label{mean_solar_anomaly}

\texttt{mean\_solar\_anomaly} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_solar\_anomaly $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_solar\_anomaly |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_solar\_longitude}}{mean\_solar\_longitude}}\label{mean_solar_longitude}

\texttt{mean\_solar\_longitude} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_solar\_longitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_solar\_longitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_squared\_error}}{mean\_squared\_error}}\label{mean_squared_error}

\texttt{mean\_squared\_error} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_squared\_error $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_squared\_error |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mean\_tone\_freq}}{mean\_tone\_freq}}\label{mean_tone_freq}

\texttt{mean\_tone\_freq} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mean\_tone\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mean\_tone\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{measure}}{measure}}\label{measure}

\texttt{measure} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = measure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map measure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mechanism\_design\_obj}}{mechanism\_design\_obj}}\label{mechanism_design_obj}

\texttt{mechanism\_design\_obj} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mechanism\_design\_obj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mechanism\_design\_obj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{medfilt}}{medfilt}}\label{medfilt}

\texttt{median\_filter(\textbackslash{}@signal,\ \$window\_size)} (alias
\texttt{medfilt}) --- applies a median filter for noise removal. Each
output is the median of the surrounding window. Excellent for removing
impulse noise while preserving edges.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @spiky = (1, 2, 100, 3, 4)   \# 100 is spike}
\NormalTok{my $clean = medfilt(\textbackslash{}@spiky, 3)}
\NormalTok{p @$clean   \# spike removed}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{medfilt\_1d}}{medfilt\_1d}}\label{medfilt_1d}

\texttt{medfilt\_1d} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = medfilt\_1d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map medfilt\_1d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{median\_absolute\_deviation}}{median\_absolute\_deviation}}\label{median_absolute_deviation}

\texttt{median\_absolute\_deviation} --- math / numeric (uncategorized
batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = median\_absolute\_deviation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map median\_absolute\_deviation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{median\_filter\_window}}{median\_filter\_window}}\label{median_filter_window}

\texttt{median\_filter\_window} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = median\_filter\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map median\_filter\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{median\_voter\_step}}{median\_voter\_step}}\label{median_voter_step}

\texttt{median\_voter\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = median\_voter\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map median\_voter\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mem\_free}}{mem\_free}}\label{mem_free}

\texttt{mem\_free} --- free/available physical RAM in bytes. On Linux
reads \texttt{MemAvailable} from \texttt{/proc/meminfo} (falls back to
\texttt{MemFree}). On macOS uses \texttt{vm.page\_free\_count} via
sysctl. Returns \texttt{undef} on unsupported platforms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mem\_free                               \# 3821666304}
\NormalTok{p format\_bytes(mem\_free)                 \# 3.6 GiB}
\NormalTok{my $pct = int(mem\_free / mem\_total * 100)}
\NormalTok{p "$pct\% free"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mem\_total}}{mem\_total}}\label{mem_total}

\texttt{mem\_total} --- total physical RAM in bytes. Uses
\texttt{/proc/meminfo} on Linux, \texttt{sysctlbyname("hw.memsize")} on
macOS. Returns \texttt{undef} on unsupported platforms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mem\_total                              \# 68719476736}
\NormalTok{p format\_bytes(mem\_total)                \# 64.0 GiB}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mem\_used}}{mem\_used}}\label{mem_used}

\texttt{mem\_used} --- used physical RAM in bytes (total - free).
Returns \texttt{undef} if either \texttt{mem\_total} or
\texttt{mem\_free} is unavailable.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(mem\_used)                 \# 60.4 GiB}
\NormalTok{gauge(mem\_used / mem\_total) |\textgreater{} p         \# memory usage gauge}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{membership\_idx}}{membership\_idx}}\label{membership_idx}

\texttt{membership\_idx} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = membership\_idx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map membership\_idx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{menhinick\_richness}}{menhinick\_richness}}\label{menhinick_richness}

\texttt{menhinick\_richness} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = menhinick\_richness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map menhinick\_richness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mercury\_perihelion\_advance}}{mercury\_perihelion\_advance}}\label{mercury_perihelion_advance}

\texttt{mercury\_perihelion\_advance} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mercury\_perihelion\_advance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mercury\_perihelion\_advance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{merge\_hash}}{merge\_hash}}\label{merge_hash}

\texttt{merge\_hash} --- hash helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = merge\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map merge\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{merge\_sorted}}{merge\_sorted}}\label{merge_sorted}

\texttt{merge\_sorted} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = merge\_sorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map merge\_sorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mertens}}{mertens}}\label{mertens}

\texttt{mertens} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mertens $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mertens |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mertens\_zamir\_step}}{mertens\_zamir\_step}}\label{mertens_zamir_step}

\texttt{mertens\_zamir\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mertens\_zamir\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mertens\_zamir\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{merton\_jump\_call}}{merton\_jump\_call}}\label{merton_jump_call}

\texttt{merton\_jump\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = merton\_jump\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map merton\_jump\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metal\_corrosion\_rate}}{metal\_corrosion\_rate}}\label{metal_corrosion_rate}

\texttt{metal\_corrosion\_rate} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metal\_corrosion\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metal\_corrosion\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metamorphic\_grade}}{metamorphic\_grade}}\label{metamorphic_grade}

\texttt{metamorphic\_grade} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metamorphic\_grade $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metamorphic\_grade |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metaphone}}{metaphone}}\label{metaphone}

\texttt{metaphone} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metaphone $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metaphone |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metaphone\_phonetic}}{metaphone\_phonetic}}\label{metaphone_phonetic}

\texttt{metaphone\_phonetic} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metaphone\_phonetic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metaphone\_phonetic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{meters\_to\_feet}}{meters\_to\_feet}}\label{meters_to_feet}

\texttt{meters\_to\_feet} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = meters\_to\_feet $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{methane\_growth\_rate}}{methane\_growth\_rate}}\label{methane_growth_rate}

\texttt{methane\_growth\_rate} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = methane\_growth\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map methane\_growth\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metonic\_cycle}}{metonic\_cycle}}\label{metonic_cycle}

\texttt{metonic\_cycle} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metonic\_cycle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metonic\_cycle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metph}}{metph}}\label{metph}

\texttt{metph} --- encoding / phonetics builtin. Alias for
\texttt{metaphone}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metph $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metph |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metric\_frw\_lapse}}{metric\_frw\_lapse}}\label{metric_frw_lapse}

\texttt{metric\_frw\_lapse} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metric\_frw\_lapse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metric\_frw\_lapse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metric\_kerr\_step\_simple}}{metric\_kerr\_step\_simple}}\label{metric_kerr_step_simple}

\texttt{metric\_kerr\_step\_simple} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metric\_kerr\_step\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metric\_kerr\_step\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metric\_minkowski\_eta\_step}}{metric\_minkowski\_eta\_step}}\label{metric_minkowski_eta_step}

\texttt{metric\_minkowski\_eta\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metric\_minkowski\_eta\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metric\_minkowski\_eta\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metric\_schwarzschild\_step}}{metric\_schwarzschild\_step}}\label{metric_schwarzschild_step}

\texttt{metric\_schwarzschild\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metric\_schwarzschild\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metric\_schwarzschild\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{metro\_hash\_64}}{metro\_hash\_64}}\label{metro_hash_64}

\texttt{metro\_hash\_64} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = metro\_hash\_64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map metro\_hash\_64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mexican\_hat\_wavelet}}{mexican\_hat\_wavelet}}\label{mexican_hat_wavelet}

\texttt{mexican\_hat\_wavelet} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mexican\_hat\_wavelet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mexican\_hat\_wavelet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mfcc\_coeff\_step}}{mfcc\_coeff\_step}}\label{mfcc_coeff_step}

\texttt{mfcc\_coeff\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mfcc\_coeff\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mfcc\_coeff\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mflat}}{mflat}}\label{mflat}

\texttt{mflat} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{matrix\_flatten}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mflat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mflat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mfromr}}{mfromr}}\label{mfromr}

\texttt{mfromr} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{matrix\_from\_rows}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mfromr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mfromr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mget}}{mget}}\label{mget}

\texttt{mget} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mgrs\_decode}}{mgrs\_decode}}\label{mgrs_decode}

\texttt{mgrs\_decode} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mgrs\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mgrs\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mgrs\_encode}}{mgrs\_encode}}\label{mgrs_encode}

\texttt{mgrs\_encode} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mgrs\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mgrs\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mhad}}{mhad}}\label{mhad}

\texttt{mhad} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_hadamard}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mhad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mhad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{michaelis\_menten}}{michaelis\_menten}}\label{michaelis_menten}

\texttt{michaelis\_menten} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = michaelis\_menten $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map michaelis\_menten |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{microlensing\_magnification}}{microlensing\_magnification}}\label{microlensing_magnification}

\texttt{microlensing\_magnification} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = microlensing\_magnification $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map microlensing\_magnification |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mid\_str}}{mid\_str}}\label{mid_str}

\texttt{mid\_str} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mid\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mid\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mident}}{mident}}\label{mident}

\texttt{mident} --- extended stdlib builtin. Alias for
\texttt{matrix\_identity}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mident $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mident |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midi\_to\_hz}}{midi\_to\_hz}}\label{midi_to_hz}

\texttt{midi\_to\_hz} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midi\_to\_hz $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midi\_to\_pitch\_class}}{midi\_to\_pitch\_class}}\label{midi_to_pitch_class}

\texttt{midi\_to\_pitch\_class} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midi\_to\_pitch\_class $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midpnt}}{midpnt}}\label{midpnt}

\texttt{midpnt} --- geometry / physics builtin. Alias for
\texttt{midpoint}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midpnt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map midpnt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midpoint}}{midpoint}}\label{midpoint}

\texttt{midpoint} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midpoint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map midpoint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midpoint\_great\_circle}}{midpoint\_great\_circle}}\label{midpoint_great_circle}

\texttt{midpoint\_great\_circle} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midpoint\_great\_circle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map midpoint\_great\_circle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midpoint\_of}}{midpoint\_of}}\label{midpoint_of}

\texttt{midpoint\_of} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midpoint\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map midpoint\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midpoint\_rule}}{midpoint\_rule}}\label{midpoint_rule}

\texttt{midpoint\_rule} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midpoint\_rule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map midpoint\_rule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{midpt}}{midpt}}\label{midpt}

\texttt{midpt} --- extended stdlib builtin. Alias for
\texttt{midpoint\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = midpt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map midpt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{miles\_to\_km}}{miles\_to\_km}}\label{miles_to_km}

\texttt{miles\_to\_km} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = miles\_to\_km $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{miles\_to\_m}}{miles\_to\_m}}\label{miles_to_m}

\texttt{miles\_to\_m} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = miles\_to\_m $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{milne}}{milne}}\label{milne}

\texttt{milne} --- batch 19 builtin. Alias for \texttt{milne\_pc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = milne $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map milne |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{milne\_pc}}{milne\_pc}}\label{milne_pc}

\texttt{milne\_pc} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = milne\_pc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map milne\_pc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{milstein\_step}}{milstein\_step}}\label{milstein_step}

\texttt{milstein\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = milstein\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map milstein\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min2}}{min2}}\label{min2}

\texttt{min2} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_abs}}{min\_abs}}\label{min_abs}

\texttt{min\_abs} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_abs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_abs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_by}}{min\_by}}\label{min_by}

\texttt{min\_by} --- functional / iterator builtin. Alias for
\texttt{take\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_cut\_value}}{min\_cut\_value}}\label{min_cut_value}

\texttt{min\_cut\_value} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_cut\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_cut\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_float}}{min\_float}}\label{min_float}

\texttt{min\_float} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_float $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_float |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_list}}{min\_list}}\label{min_list}

\texttt{min\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_max}}{min\_max}}\label{min_max}

\texttt{min\_max} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_of}}{min\_of}}\label{min_of}

\texttt{min\_of} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_steiner\_tree}}{min\_steiner\_tree}}\label{min_steiner_tree}

\texttt{min\_steiner\_tree} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_steiner\_tree $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_steiner\_tree |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{min\_vertex\_cover}}{min\_vertex\_cover}}\label{min_vertex_cover}

\texttt{min\_vertex\_cover} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = min\_vertex\_cover $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map min\_vertex\_cover |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minby}}{minby}}\label{minby}

\texttt{minby} --- additional missing stdlib functions builtin. Alias
for \texttt{minimum\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mincut\_stoer\_wagner}}{mincut\_stoer\_wagner}}\label{mincut_stoer_wagner}

\texttt{mincut\_stoer\_wagner} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mincut\_stoer\_wagner $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mincut\_stoer\_wagner |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mineral\_mohs\_hardness}}{mineral\_mohs\_hardness}}\label{mineral_mohs_hardness}

\texttt{mineral\_mohs\_hardness} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mineral\_mohs\_hardness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mineral\_mohs\_hardness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minimum\_by}}{minimum\_by}}\label{minimum_by}

\texttt{minimum\_by} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minimum\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minimum\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minkdist}}{minkdist}}\label{minkdist}

\texttt{minkdist} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{minkowski\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minkdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minkdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minkowski\_distance}}{minkowski\_distance}}\label{minkowski_distance}

\texttt{minkowski\_distance} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minkowski\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minkowski\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minkowski\_sum\_simple}}{minkowski\_sum\_simple}}\label{minkowski_sum_simple}

\texttt{minkowski\_sum\_simple} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minkowski\_sum\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minkowski\_sum\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minmax}}{minmax}}\label{minmax}

\texttt{minmax} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minmax\_by}}{minmax\_by}}\label{minmax_by}

\texttt{minmax\_by} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minmax\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minmax\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minmax\_scale}}{minmax\_scale}}\label{minmax_scale}

\texttt{minmax\_scale} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minmax\_scale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minmax\_scale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minmod\_limiter}}{minmod\_limiter}}\label{minmod_limiter}

\texttt{minmod\_limiter} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minmod\_limiter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minmod\_limiter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minstr}}{minstr}}\label{minstr}

\texttt{minstr} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minstr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minstr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minutes\_to\_hours}}{minutes\_to\_hours}}\label{minutes_to_hours}

\texttt{minutes\_to\_hours} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minutes\_to\_hours $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minutes\_to\_seconds}}{minutes\_to\_seconds}}\label{minutes_to_seconds}

\texttt{minutes\_to\_seconds} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minutes\_to\_seconds $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{minv}}{minv}}\label{minv}

\texttt{minv} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_inverse}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = minv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map minv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mirr}}{mirr}}\label{mirr}

\texttt{mirr} --- batch 10 builtin. Alias for \texttt{modified\_irr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mirr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mirr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mirr\_excel}}{mirr\_excel}}\label{mirr_excel}

\texttt{mirr\_excel} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mirr\_excel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mirr\_excel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mirror\_descent\_step}}{mirror\_descent\_step}}\label{mirror_descent_step}

\texttt{mirror\_descent\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mirror\_descent\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mirror\_descent\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mirror\_equation\_v}}{mirror\_equation\_v}}\label{mirror_equation_v}

\texttt{mirror\_equation\_v} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mirror\_equation\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mirror\_equation\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mirror\_string}}{mirror\_string}}\label{mirror_string}

\texttt{mirror\_string} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mirror\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mirror\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mirror\_symmetry\_check}}{mirror\_symmetry\_check}}\label{mirror_symmetry_check}

\texttt{mirror\_symmetry\_check} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mirror\_symmetry\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mirror\_symmetry\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mish}}{mish}}\label{mish}

\texttt{mish} applies the Mish activation: x·tanh(softplus(x)). Often
outperforms ReLU/Swish.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mish(1)    \# 0.8651}
\NormalTok{p mish({-}1)   \# {-}0.3034}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mixed\_integer\_round\_down}}{mixed\_integer\_round\_down}}\label{mixed_integer_round_down}

\texttt{mixed\_integer\_round\_down} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mixed\_integer\_round\_down $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mixed\_integer\_round\_down |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mixed\_integer\_round\_up}}{mixed\_integer\_round\_up}}\label{mixed_integer_round_up}

\texttt{mixed\_integer\_round\_up} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mixed\_integer\_round\_up $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mixed\_integer\_round\_up |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mixed\_potential\_step}}{mixed\_potential\_step}}\label{mixed_potential_step}

\texttt{mixed\_potential\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mixed\_potential\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mixed\_potential\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mixed\_strategy\_value}}{mixed\_strategy\_value}}\label{mixed_strategy_value}

\texttt{mixed\_strategy\_value} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mixed\_strategy\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mixed\_strategy\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mixing\_length\_prandtl}}{mixing\_length\_prandtl}}\label{mixing_length_prandtl}

\texttt{mixing\_length\_prandtl} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mixing\_length\_prandtl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mixing\_length\_prandtl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mjo\_phase\_step}}{mjo\_phase\_step}}\label{mjo_phase_step}

\texttt{mjo\_phase\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mjo\_phase\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mjo\_phase\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_adabelief\_step}}{ml\_adabelief\_step}}\label{ml_adabelief_step}

\texttt{ml\_adabelief\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_adabelief\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_adabelief\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_adagrad\_step}}{ml\_adagrad\_step}}\label{ml_adagrad_step}

\texttt{ml\_adagrad\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_adagrad\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_adagrad\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_adam\_step}}{ml\_adam\_step}}\label{ml_adam_step}

\texttt{ml\_adam\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_adam\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_adam\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_adamax\_step}}{ml\_adamax\_step}}\label{ml_adamax_step}

\texttt{ml\_adamax\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_adamax\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_adamax\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_adamw\_step}}{ml\_adamw\_step}}\label{ml_adamw_step}

\texttt{ml\_adamw\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_adamw\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_adamw\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_amsgrad\_step}}{ml\_amsgrad\_step}}\label{ml_amsgrad_step}

\texttt{ml\_amsgrad\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_amsgrad\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_amsgrad\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_arcface\_loss\_step}}{ml\_arcface\_loss\_step}}\label{ml_arcface_loss_step}

\texttt{ml\_arcface\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_arcface\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_arcface\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_attention\_score\_step}}{ml\_attention\_score\_step}}\label{ml_attention_score_step}

\texttt{ml\_attention\_score\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_attention\_score\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_attention\_score\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_batch\_norm\_step}}{ml\_batch\_norm\_step}}\label{ml_batch_norm_step}

\texttt{ml\_batch\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_batch\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_batch\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_binary\_cross\_entropy}}{ml\_binary\_cross\_entropy}}\label{ml_binary_cross_entropy}

\texttt{ml\_binary\_cross\_entropy} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_binary\_cross\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_binary\_cross\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_celu\_step}}{ml\_celu\_step}}\label{ml_celu_step}

\texttt{ml\_celu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_celu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_celu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_center\_loss\_step}}{ml\_center\_loss\_step}}\label{ml_center_loss_step}

\texttt{ml\_center\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_center\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_center\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_ciou\_loss\_step}}{ml\_ciou\_loss\_step}}\label{ml_ciou_loss_step}

\texttt{ml\_ciou\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_ciou\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_ciou\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_constant\_init}}{ml\_constant\_init}}\label{ml_constant_init}

\texttt{ml\_constant\_init} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_constant\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_constant\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_contrastive\_loss}}{ml\_contrastive\_loss}}\label{ml_contrastive_loss}

\texttt{ml\_contrastive\_loss} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_contrastive\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_contrastive\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_cosine\_lr\_schedule}}{ml\_cosine\_lr\_schedule}}\label{ml_cosine_lr_schedule}

\texttt{ml\_cosine\_lr\_schedule} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_cosine\_lr\_schedule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_cosine\_lr\_schedule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_cross\_entropy\_loss}}{ml\_cross\_entropy\_loss}}\label{ml_cross_entropy_loss}

\texttt{ml\_cross\_entropy\_loss} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_cross\_entropy\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_cross\_entropy\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_cutmix\_box\_iou}}{ml\_cutmix\_box\_iou}}\label{ml_cutmix_box_iou}

\texttt{ml\_cutmix\_box\_iou} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_cutmix\_box\_iou $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_cutmix\_box\_iou |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_cyclic\_lr\_step}}{ml\_cyclic\_lr\_step}}\label{ml_cyclic_lr_step}

\texttt{ml\_cyclic\_lr\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_cyclic\_lr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_cyclic\_lr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_dice\_loss\_step}}{ml\_dice\_loss\_step}}\label{ml_dice_loss_step}

\texttt{ml\_dice\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_dice\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_dice\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_diou\_loss\_step}}{ml\_diou\_loss\_step}}\label{ml_diou_loss_step}

\texttt{ml\_diou\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_diou\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_diou\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_dropout\_mask\_prob}}{ml\_dropout\_mask\_prob}}\label{ml_dropout_mask_prob}

\texttt{ml\_dropout\_mask\_prob} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_dropout\_mask\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_dropout\_mask\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_elu\_step}}{ml\_elu\_step}}\label{ml_elu_step}

\texttt{ml\_elu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_elu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_elu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_eos\_logit\_boost}}{ml\_eos\_logit\_boost}}\label{ml_eos_logit_boost}

\texttt{ml\_eos\_logit\_boost} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_eos\_logit\_boost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_eos\_logit\_boost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_exponential\_lr}}{ml\_exponential\_lr}}\label{ml_exponential_lr}

\texttt{ml\_exponential\_lr} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_exponential\_lr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_exponential\_lr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_focal\_loss\_step}}{ml\_focal\_loss\_step}}\label{ml_focal_loss_step}

\texttt{ml\_focal\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_focal\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_focal\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_geglu\_step}}{ml\_geglu\_step}}\label{ml_geglu_step}

\texttt{ml\_geglu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_geglu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_geglu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_gelu\_step}}{ml\_gelu\_step}}\label{ml_gelu_step}

\texttt{ml\_gelu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_gelu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_gelu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_giou\_loss\_step}}{ml\_giou\_loss\_step}}\label{ml_giou_loss_step}

\texttt{ml\_giou\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_giou\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_giou\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_glorot\_init\_value}}{ml\_glorot\_init\_value}}\label{ml_glorot_init_value}

\texttt{ml\_glorot\_init\_value} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_glorot\_init\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_glorot\_init\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_glu\_step}}{ml\_glu\_step}}\label{ml_glu_step}

\texttt{ml\_glu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_glu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_glu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_gradient\_accumulate}}{ml\_gradient\_accumulate}}\label{ml_gradient_accumulate}

\texttt{ml\_gradient\_accumulate} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_gradient\_accumulate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_gradient\_accumulate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_gradient\_centralize}}{ml\_gradient\_centralize}}\label{ml_gradient_centralize}

\texttt{ml\_gradient\_centralize} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_gradient\_centralize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_gradient\_centralize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_gradient\_clip\_norm}}{ml\_gradient\_clip\_norm}}\label{ml_gradient_clip_norm}

\texttt{ml\_gradient\_clip\_norm} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_gradient\_clip\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_gradient\_clip\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_gradient\_clip\_value}}{ml\_gradient\_clip\_value}}\label{ml_gradient_clip_value}

\texttt{ml\_gradient\_clip\_value} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_gradient\_clip\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_gradient\_clip\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_group\_norm\_step}}{ml\_group\_norm\_step}}\label{ml_group_norm_step}

\texttt{ml\_group\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_group\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_group\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_hard\_sigmoid}}{ml\_hard\_sigmoid}}\label{ml_hard_sigmoid}

\texttt{ml\_hard\_sigmoid} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_hard\_sigmoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_hard\_sigmoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_hard\_tanh}}{ml\_hard\_tanh}}\label{ml_hard_tanh}

\texttt{ml\_hard\_tanh} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_hard\_tanh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_hard\_tanh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_he\_init\_value}}{ml\_he\_init\_value}}\label{ml_he_init_value}

\texttt{ml\_he\_init\_value} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_he\_init\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_he\_init\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_huber\_loss\_step}}{ml\_huber\_loss\_step}}\label{ml_huber_loss_step}

\texttt{ml\_huber\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_huber\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_huber\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_id\_to\_label\_step}}{ml\_id\_to\_label\_step}}\label{ml_id_to_label_step}

\texttt{ml\_id\_to\_label\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_id\_to\_label\_step $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_instance\_norm\_step}}{ml\_instance\_norm\_step}}\label{ml_instance_norm_step}

\texttt{ml\_instance\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_instance\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_instance\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_inverse\_sqrt\_lr}}{ml\_inverse\_sqrt\_lr}}\label{ml_inverse_sqrt_lr}

\texttt{ml\_inverse\_sqrt\_lr} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_inverse\_sqrt\_lr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_inverse\_sqrt\_lr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_iou\_loss\_step}}{ml\_iou\_loss\_step}}\label{ml_iou_loss_step}

\texttt{ml\_iou\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_iou\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_iou\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_kaiming\_init}}{ml\_kaiming\_init}}\label{ml_kaiming_init}

\texttt{ml\_kaiming\_init} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_kaiming\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_kaiming\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_kl\_divergence\_loss}}{ml\_kl\_divergence\_loss}}\label{ml_kl_divergence_loss}

\texttt{ml\_kl\_divergence\_loss} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_kl\_divergence\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_kl\_divergence\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_l2\_normalize\_step}}{ml\_l2\_normalize\_step}}\label{ml_l2_normalize_step}

\texttt{ml\_l2\_normalize\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_l2\_normalize\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_l2\_normalize\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_label\_smoothing}}{ml\_label\_smoothing}}\label{ml_label_smoothing}

\texttt{ml\_label\_smoothing} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_label\_smoothing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_label\_smoothing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_label\_to\_id}}{ml\_label\_to\_id}}\label{ml_label_to_id}

\texttt{ml\_label\_to\_id} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_label\_to\_id $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_lamb\_step}}{ml\_lamb\_step}}\label{ml_lamb_step}

\texttt{ml\_lamb\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_lamb\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_lamb\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_lars\_step}}{ml\_lars\_step}}\label{ml_lars_step}

\texttt{ml\_lars\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_lars\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_lars\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_layer\_norm\_step}}{ml\_layer\_norm\_step}}\label{ml_layer_norm_step}

\texttt{ml\_layer\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_layer\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_layer\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_leaky\_relu\_step}}{ml\_leaky\_relu\_step}}\label{ml_leaky_relu_step}

\texttt{ml\_leaky\_relu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_leaky\_relu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_leaky\_relu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_lecun\_init\_value}}{ml\_lecun\_init\_value}}\label{ml_lecun_init_value}

\texttt{ml\_lecun\_init\_value} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_lecun\_init\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_lecun\_init\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_lion\_step}}{ml\_lion\_step}}\label{ml_lion_step}

\texttt{ml\_lion\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_lion\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_lion\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_log\_sigmoid}}{ml\_log\_sigmoid}}\label{ml_log_sigmoid}

\texttt{ml\_log\_sigmoid} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_log\_sigmoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_log\_sigmoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_log\_softmax\_step}}{ml\_log\_softmax\_step}}\label{ml_log_softmax_step}

\texttt{ml\_log\_softmax\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_log\_softmax\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_log\_softmax\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_logsumexp\_step}}{ml\_logsumexp\_step}}\label{ml_logsumexp_step}

\texttt{ml\_logsumexp\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_logsumexp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_logsumexp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_lookahead\_step}}{ml\_lookahead\_step}}\label{ml_lookahead_step}

\texttt{ml\_lookahead\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_lookahead\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_lookahead\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_mish\_step}}{ml\_mish\_step}}\label{ml_mish_step}

\texttt{ml\_mish\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_mish\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_mish\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_mixup\_lambda}}{ml\_mixup\_lambda}}\label{ml_mixup_lambda}

\texttt{ml\_mixup\_lambda} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_mixup\_lambda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_mixup\_lambda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_momentum\_step}}{ml\_momentum\_step}}\label{ml_momentum_step}

\texttt{ml\_momentum\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_momentum\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_momentum\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_multihead\_avg}}{ml\_multihead\_avg}}\label{ml_multihead_avg}

\texttt{ml\_multihead\_avg} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_multihead\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_multihead\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_nadam\_step}}{ml\_nadam\_step}}\label{ml_nadam_step}

\texttt{ml\_nadam\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_nadam\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_nadam\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_nesterov\_momentum}}{ml\_nesterov\_momentum}}\label{ml_nesterov_momentum}

\texttt{ml\_nesterov\_momentum} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_nesterov\_momentum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_nesterov\_momentum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_nucleus\_sample\_p}}{ml\_nucleus\_sample\_p}}\label{ml_nucleus_sample_p}

\texttt{ml\_nucleus\_sample\_p} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_nucleus\_sample\_p $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_nucleus\_sample\_p |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_one\_cycle\_lr}}{ml\_one\_cycle\_lr}}\label{ml_one_cycle_lr}

\texttt{ml\_one\_cycle\_lr} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_one\_cycle\_lr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_one\_cycle\_lr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_one\_hot\_index}}{ml\_one\_hot\_index}}\label{ml_one_hot_index}

\texttt{ml\_one\_hot\_index} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_one\_hot\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_one\_hot\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_orthogonal\_init}}{ml\_orthogonal\_init}}\label{ml_orthogonal_init}

\texttt{ml\_orthogonal\_init} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_orthogonal\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_orthogonal\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_polynomial\_lr}}{ml\_polynomial\_lr}}\label{ml_polynomial_lr}

\texttt{ml\_polynomial\_lr} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_polynomial\_lr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_polynomial\_lr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_prelu\_step}}{ml\_prelu\_step}}\label{ml_prelu_step}

\texttt{ml\_prelu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_prelu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_prelu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_radam\_step}}{ml\_radam\_step}}\label{ml_radam_step}

\texttt{ml\_radam\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_radam\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_radam\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_random\_erasing\_step}}{ml\_random\_erasing\_step}}\label{ml_random_erasing_step}

\texttt{ml\_random\_erasing\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_random\_erasing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_random\_erasing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_relu\_step}}{ml\_relu\_step}}\label{ml_relu_step}

\texttt{ml\_relu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_relu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_relu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_repetition\_penalty}}{ml\_repetition\_penalty}}\label{ml_repetition_penalty}

\texttt{ml\_repetition\_penalty} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_repetition\_penalty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_repetition\_penalty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_rms\_norm\_step}}{ml\_rms\_norm\_step}}\label{ml_rms_norm_step}

\texttt{ml\_rms\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_rms\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_rms\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_rmsprop\_step}}{ml\_rmsprop\_step}}\label{ml_rmsprop_step}

\texttt{ml\_rmsprop\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_rmsprop\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_rmsprop\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_scaled\_dot\_product}}{ml\_scaled\_dot\_product}}\label{ml_scaled_dot_product}

\texttt{ml\_scaled\_dot\_product} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_scaled\_dot\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_scaled\_dot\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_selu\_step}}{ml\_selu\_step}}\label{ml_selu_step}

\texttt{ml\_selu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_selu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_selu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_sgd\_step}}{ml\_sgd\_step}}\label{ml_sgd_step}

\texttt{ml\_sgd\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_sgd\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_sgd\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_shampoo\_step}}{ml\_shampoo\_step}}\label{ml_shampoo_step}

\texttt{ml\_shampoo\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_shampoo\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_shampoo\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_silu\_step}}{ml\_silu\_step}}\label{ml_silu_step}

\texttt{ml\_silu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_silu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_silu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_smooth\_l1\_loss}}{ml\_smooth\_l1\_loss}}\label{ml_smooth_l1_loss}

\texttt{ml\_smooth\_l1\_loss} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_smooth\_l1\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_smooth\_l1\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_softmax\_temperature}}{ml\_softmax\_temperature}}\label{ml_softmax_temperature}

\texttt{ml\_softmax\_temperature} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_softmax\_temperature $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_softmax\_temperature |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_softplus\_step}}{ml\_softplus\_step}}\label{ml_softplus_step}

\texttt{ml\_softplus\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_softplus\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_softplus\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_softsign\_step}}{ml\_softsign\_step}}\label{ml_softsign_step}

\texttt{ml\_softsign\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_softsign\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_softsign\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_sophia\_step}}{ml\_sophia\_step}}\label{ml_sophia_step}

\texttt{ml\_sophia\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_sophia\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_sophia\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_spectral\_norm\_step}}{ml\_spectral\_norm\_step}}\label{ml_spectral_norm_step}

\texttt{ml\_spectral\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_spectral\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_spectral\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_step\_lr\_schedule}}{ml\_step\_lr\_schedule}}\label{ml_step_lr_schedule}

\texttt{ml\_step\_lr\_schedule} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_step\_lr\_schedule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_step\_lr\_schedule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_swiglu\_step}}{ml\_swiglu\_step}}\label{ml_swiglu_step}

\texttt{ml\_swiglu\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_swiglu\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_swiglu\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_swish\_step}}{ml\_swish\_step}}\label{ml_swish_step}

\texttt{ml\_swish\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_swish\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_swish\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_temperature\_decay}}{ml\_temperature\_decay}}\label{ml_temperature_decay}

\texttt{ml\_temperature\_decay} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_temperature\_decay $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_temperature\_decay |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_to\_cups}}{ml\_to\_cups}}\label{ml_to_cups}

\texttt{ml\_to\_cups} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_to\_cups $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_to\_liters}}{ml\_to\_liters}}\label{ml_to_liters}

\texttt{ml\_to\_liters} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_to\_liters $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_token\_logit\_top\_k}}{ml\_token\_logit\_top\_k}}\label{ml_token_logit_top_k}

\texttt{ml\_token\_logit\_top\_k} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_token\_logit\_top\_k $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_token\_logit\_top\_k |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_topk\_argmax}}{ml\_topk\_argmax}}\label{ml_topk_argmax}

\texttt{ml\_topk\_argmax} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_topk\_argmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_topk\_argmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_triplet\_loss\_step}}{ml\_triplet\_loss\_step}}\label{ml_triplet_loss_step}

\texttt{ml\_triplet\_loss\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_triplet\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_triplet\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_truncnormal\_init}}{ml\_truncnormal\_init}}\label{ml_truncnormal_init}

\texttt{ml\_truncnormal\_init} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_truncnormal\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_truncnormal\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_uniform\_init}}{ml\_uniform\_init}}\label{ml_uniform_init}

\texttt{ml\_uniform\_init} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_uniform\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_uniform\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_warmup\_lr\_step}}{ml\_warmup\_lr\_step}}\label{ml_warmup_lr_step}

\texttt{ml\_warmup\_lr\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_warmup\_lr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_warmup\_lr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_weight\_decay\_step}}{ml\_weight\_decay\_step}}\label{ml_weight_decay_step}

\texttt{ml\_weight\_decay\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_weight\_decay\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_weight\_decay\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_weight\_norm\_step}}{ml\_weight\_norm\_step}}\label{ml_weight_norm_step}

\texttt{ml\_weight\_norm\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_weight\_norm\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_weight\_norm\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_xavier\_init\_value}}{ml\_xavier\_init\_value}}\label{ml_xavier_init_value}

\texttt{ml\_xavier\_init\_value} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_xavier\_init\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_xavier\_init\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_yogi\_step}}{ml\_yogi\_step}}\label{ml_yogi_step}

\texttt{ml\_yogi\_step} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_yogi\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_yogi\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ml\_zero\_init}}{ml\_zero\_init}}\label{ml_zero_init}

\texttt{ml\_zero\_init} --- batch 45 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ml\_zero\_init $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ml\_zero\_init |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mle\_exponential\_log\_lik}}{mle\_exponential\_log\_lik}}\label{mle_exponential_log_lik}

\texttt{mle\_exponential\_log\_lik} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mle\_exponential\_log\_lik $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mle\_exponential\_log\_lik |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mle\_normal\_log\_lik}}{mle\_normal\_log\_lik}}\label{mle_normal_log_lik}

\texttt{mle\_normal\_log\_lik} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mle\_normal\_log\_lik $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mle\_normal\_log\_lik |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mle\_poisson\_log\_lik}}{mle\_poisson\_log\_lik}}\label{mle_poisson_log_lik}

\texttt{mle\_poisson\_log\_lik} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mle\_poisson\_log\_lik $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mle\_poisson\_log\_lik |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mm}}{mm}}\label{mm}

\texttt{mm} --- extended stdlib builtin. Alias for \texttt{matrix\_mul}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmap}}{mmap}}\label{mmap}

\texttt{mmap} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_map}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmax}}{mmax}}\label{mmax}

\texttt{mmax} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_max}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmhg\_to\_pa}}{mmhg\_to\_pa}}\label{mmhg_to_pa}

\texttt{mmhg\_to\_pa} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmhg\_to\_pa $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmin}}{mmin}}\label{mmin}

\texttt{mmin} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_min}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mmin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmult}}{mmult}}\label{mmult}

\texttt{mmult} --- extended stdlib builtin. Alias for
\texttt{matrix\_mult}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmult $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mmult |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmx}}{mmx}}\label{mmx}

\texttt{mmx} --- python/ruby stdlib builtin. Alias for \texttt{minmax}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mmx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mmxb}}{mmxb}}\label{mmxb}

\texttt{mmxb} --- python/ruby stdlib builtin. Alias for
\texttt{minmax\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mmxb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mmxb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mob}}{mob}}\label{mob}

\texttt{mob} --- extended stdlib batch 3 builtin. Alias for
\texttt{mobius}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mobius}}{mobius}}\label{mobius}

\texttt{mobius} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mobius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mobius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mobius\_function\_pair}}{mobius\_function\_pair}}\label{mobius_function_pair}

\texttt{mobius\_function\_pair} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mobius\_function\_pair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mobius\_function\_pair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mobius\_inversion\_step}}{mobius\_inversion\_step}}\label{mobius_inversion_step}

\texttt{mobius\_inversion\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mobius\_inversion\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mobius\_inversion\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mobius\_poset\_two}}{mobius\_poset\_two}}\label{mobius_poset_two}

\texttt{mobius\_poset\_two} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mobius\_poset\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mobius\_poset\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mod\_exp}}{mod\_exp}}\label{mod_exp}

\texttt{mod\_exp} (aliases \texttt{modexp}, \texttt{powmod}) computes
modular exponentiation: base\^{}exp mod m, using fast binary
exponentiation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p powmod(2, 10, 1000)  \# 24 (2\^{}10 mod 1000)}
\NormalTok{p powmod(3, 13, 50)    \# 7}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mod\_inv}}{mod\_inv}}\label{mod_inv}

\texttt{mod\_inv} (alias \texttt{modinv}) computes the modular
multiplicative inverse via extended Euclidean algorithm. Errors if no
inverse exists.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p modinv(3, 7)   \# 5 (3*5 ≡ 1 mod 7)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mod\_op}}{mod\_op}}\label{mod_op}

\texttt{mod\_op} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mod\_op $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mod\_op |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mod\_sph\_bessel\_i0}}{mod\_sph\_bessel\_i0}}\label{mod_sph_bessel_i0}

\texttt{mod\_sph\_bessel\_i0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mod\_sph\_bessel\_i0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mod\_sph\_bessel\_i0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mod\_sph\_bessel\_i1}}{mod\_sph\_bessel\_i1}}\label{mod_sph_bessel_i1}

\texttt{mod\_sph\_bessel\_i1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mod\_sph\_bessel\_i1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mod\_sph\_bessel\_i1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mod\_sph\_bessel\_k0}}{mod\_sph\_bessel\_k0}}\label{mod_sph_bessel_k0}

\texttt{mod\_sph\_bessel\_k0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mod\_sph\_bessel\_k0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mod\_sph\_bessel\_k0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moddur}}{moddur}}\label{moddur}

\texttt{moddur} --- finance (extended) builtin. Alias for
\texttt{modified\_duration}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moddur $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moddur |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_agg}}{mode\_agg}}\label{mode_agg}

\texttt{mode\_agg} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_agg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_agg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_list}}{mode\_list}}\label{mode_list}

\texttt{mode\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_pitches\_dorian}}{mode\_pitches\_dorian}}\label{mode_pitches_dorian}

\texttt{mode\_pitches\_dorian} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_pitches\_dorian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_pitches\_dorian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_pitches\_lydian}}{mode\_pitches\_lydian}}\label{mode_pitches_lydian}

\texttt{mode\_pitches\_lydian} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_pitches\_lydian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_pitches\_lydian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_pitches\_phrygian}}{mode\_pitches\_phrygian}}\label{mode_pitches_phrygian}

\texttt{mode\_pitches\_phrygian} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_pitches\_phrygian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_pitches\_phrygian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_stat}}{mode\_stat}}\label{mode_stat}

\texttt{mode\_stat} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mode\_val}}{mode\_val}}\label{mode_val}

\texttt{mode\_val} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mode\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mode\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{model\_checking\_ctl}}{model\_checking\_ctl}}\label{model_checking_ctl}

\texttt{model\_checking\_ctl} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = model\_checking\_ctl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map model\_checking\_ctl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{model\_checking\_ltl}}{model\_checking\_ltl}}\label{model_checking_ltl}

\texttt{model\_checking\_ltl} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = model\_checking\_ltl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map model\_checking\_ltl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modhex\_encode}}{modhex\_encode}}\label{modhex_encode}

\texttt{modhex\_encode} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modhex\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modhex\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modified\_duration}}{modified\_duration}}\label{modified_duration}

\texttt{modified\_duration(\$face,\ \$coupon\_rate,\ \$ytm,\ \$periods)}
(alias \texttt{mod\_dur}) --- computes modified duration, which directly
measures price sensitivity to yield changes. Equal to Macaulay duration
/ (1 + ytm).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mod\_dur(1000, 0.05, 0.05, 10)   \# \textasciitilde{}7.3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modified\_irr}}{modified\_irr}}\label{modified_irr}

\texttt{modified\_irr} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modified\_irr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modified\_irr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modified\_midpoint\_ode}}{modified\_midpoint\_ode}}\label{modified_midpoint_ode}

\texttt{modified\_midpoint\_ode} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modified\_midpoint\_ode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modified\_midpoint\_ode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modified\_sharpe}}{modified\_sharpe}}\label{modified_sharpe}

\texttt{modified\_sharpe} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modified\_sharpe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modified\_sharpe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modmidpoint}}{modmidpoint}}\label{modmidpoint}

\texttt{modmidpoint} --- batch 19 builtin. Alias for
\texttt{modified\_midpoint\_ode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modmidpoint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modmidpoint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modular\_data\_s\_value}}{modular\_data\_s\_value}}\label{modular_data_s_value}

\texttt{modular\_data\_s\_value} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modular\_data\_s\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modular\_data\_s\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modular\_data\_t\_value}}{modular\_data\_t\_value}}\label{modular_data_t_value}

\texttt{modular\_data\_t\_value} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modular\_data\_t\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modular\_data\_t\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modularity\_q}}{modularity\_q}}\label{modularity_q}

\texttt{modularity\_q} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modularity\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modularity\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{modularity\_score}}{modularity\_score}}\label{modularity_score}

\texttt{modularity\_score} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = modularity\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map modularity\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moduli\_dimension\_curves}}{moduli\_dimension\_curves}}\label{moduli_dimension_curves}

\texttt{moduli\_dimension\_curves} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moduli\_dimension\_curves $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moduli\_dimension\_curves |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{molality}}{molality}}\label{molality}

\texttt{molality} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = molality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map molality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{molarity}}{molarity}}\label{molarity}

\texttt{molarity} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = molarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map molarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{molarity\_dilution}}{molarity\_dilution}}\label{molarity_dilution}

\texttt{molarity\_dilution} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = molarity\_dilution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map molarity\_dilution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mole\_fraction}}{mole\_fraction}}\label{mole_fraction}

\texttt{mole\_fraction} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mole\_fraction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mole\_fraction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{molecular\_weight\_compound}}{molecular\_weight\_compound}}\label{molecular_weight_compound}

\texttt{molecular\_weight\_compound} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = molecular\_weight\_compound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map molecular\_weight\_compound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moles\_from\_mass}}{moles\_from\_mass}}\label{moles_from_mass}

\texttt{moles\_from\_mass} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moles\_from\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moles\_from\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mollweide\_project}}{mollweide\_project}}\label{mollweide_project}

\texttt{mollweide\_project} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mollweide\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mollweide\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moment\_magnitude\_mw}}{moment\_magnitude\_mw}}\label{moment_magnitude_mw}

\texttt{moment\_magnitude\_mw} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moment\_magnitude\_mw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moment\_magnitude\_mw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{momentum}}{momentum}}\label{momentum}

\texttt{momentum(\$mass,\ \$velocity)} --- compute momentum p = mv
(kg⋅m/s).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p momentum(10, 5)   \# 50 kg⋅m/s}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mones}}{mones}}\label{mones}

\texttt{mones} --- extended stdlib builtin. Alias for
\texttt{matrix\_ones}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mones $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mones |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{monin\_obukhov\_length}}{monin\_obukhov\_length}}\label{monin_obukhov_length}

\texttt{monin\_obukhov\_length} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = monin\_obukhov\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map monin\_obukhov\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{monobit\_test}}{monobit\_test}}\label{monobit_test}

\texttt{monobit\_test} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = monobit\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map monobit\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{monopoly\_lerner}}{monopoly\_lerner}}\label{monopoly_lerner}

\texttt{monopoly\_lerner} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = monopoly\_lerner $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map monopoly\_lerner |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{montecarlo\_returns\_step}}{montecarlo\_returns\_step}}\label{montecarlo_returns_step}

\texttt{montecarlo\_returns\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = montecarlo\_returns\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map montecarlo\_returns\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{month\_name}}{month\_name}}\label{month_name}

\texttt{month\_name} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = month\_name $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map month\_name |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{month\_short}}{month\_short}}\label{month_short}

\texttt{month\_short} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = month\_short $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map month\_short |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{months\_between}}{months\_between}}\label{months_between}

\texttt{months\_between} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = months\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map months\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{montreal\_protocol\_track}}{montreal\_protocol\_track}}\label{montreal_protocol_track}

\texttt{montreal\_protocol\_track} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = montreal\_protocol\_track $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map montreal\_protocol\_track |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moon\_phase}}{moon\_phase}}\label{moon_phase}

\texttt{moon\_phase} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moon\_phase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moon\_phase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moon\_phase\_age}}{moon\_phase\_age}}\label{moon_phase_age}

\texttt{moon\_phase\_age} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moon\_phase\_age $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moon\_phase\_age |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moon\_position\_low}}{moon\_position\_low}}\label{moon_position_low}

\texttt{moon\_position\_low} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moon\_position\_low $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moon\_position\_low |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{morse}}{morse}}\label{morse}

\texttt{morse} --- encoding / phonetics builtin. Alias for
\texttt{morse\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = morse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map morse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{morse\_decode}}{morse\_decode}}\label{morse_decode}

\texttt{morse\_decode} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = morse\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map morse\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{morse\_encode}}{morse\_encode}}\label{morse_encode}

\texttt{morse\_encode} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = morse\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map morse\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mortality\_table\_q}}{mortality\_table\_q}}\label{mortality_table_q}

\texttt{mortality\_table\_q} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mortality\_table\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mortality\_table\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mortgage\_payment}}{mortgage\_payment}}\label{mortgage_payment}

\texttt{mortgage\_payment} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mortgage\_payment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mortgage\_payment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{most\_common}}{most\_common}}\label{most_common}

\texttt{most\_common} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = most\_common $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map most\_common |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{motion\_blur\_kernel}}{motion\_blur\_kernel}}\label{motion_blur_kernel}

\texttt{motion\_blur\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = motion\_blur\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map motion\_blur\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{motor\_torque}}{motor\_torque}}\label{motor_torque}

\texttt{motor\_torque} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = motor\_torque $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map motor\_torque |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mott\_schottky\_capacitance}}{mott\_schottky\_capacitance}}\label{mott_schottky_capacitance}

\texttt{mott\_schottky\_capacitance} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mott\_schottky\_capacitance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mott\_schottky\_capacitance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{movavg}}{movavg}}\label{movavg}

\texttt{movavg} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{moving\_average}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = movavg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map movavg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moving\_average}}{moving\_average}}\label{moving_average}

\texttt{moving\_average} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moving\_average $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moving\_average |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{moving\_average\_filter}}{moving\_average\_filter}}\label{moving_average_filter}

\texttt{moving\_average\_filter} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = moving\_average\_filter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map moving\_average\_filter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mpeg\_quant\_value}}{mpeg\_quant\_value}}\label{mpeg_quant_value}

\texttt{mpeg\_quant\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mpeg\_quant\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mpeg\_quant\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mph\_to\_kmh}}{mph\_to\_kmh}}\label{mph_to_kmh}

\texttt{mph\_to\_kmh} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mph\_to\_kmh $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mplanck}}{mplanck}}\label{mplanck}

\texttt{mplanck} --- physics constants builtin. Alias for
\texttt{planck\_mass}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mplanck $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mplanck |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mpow}}{mpow}}\label{mpow}

\texttt{mpow} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_power}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mpow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mpow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mps\_to\_kmh}}{mps\_to\_kmh}}\label{mps_to_kmh}

\texttt{mps\_to\_kmh} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mps\_to\_kmh $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mrow}}{mrow}}\label{mrow}

\texttt{mrow} --- extended stdlib builtin. Alias for
\texttt{matrix\_row}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mrow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mrow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ms\_to\_ns}}{ms\_to\_ns}}\label{ms_to_ns}

\texttt{ms\_to\_ns} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ms\_to\_ns $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ms\_to\_s}}{ms\_to\_s}}\label{ms_to_s}

\texttt{ms\_to\_s} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ms\_to\_s $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msa\_column\_entropy}}{msa\_column\_entropy}}\label{msa_column_entropy}

\texttt{msa\_column\_entropy} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msa\_column\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msa\_column\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mscal}}{mscal}}\label{mscal}

\texttt{mscal} --- extended stdlib builtin. Alias for
\texttt{matrix\_scalar}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mscal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mscal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mse}}{mse}}\label{mse}

\texttt{mse} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mset}}{mset}}\label{mset}

\texttt{mset} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msgctl}}{msgctl}}\label{msgctl}

\texttt{msgctl} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msgctl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msgctl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msgget}}{msgget}}\label{msgget}

\texttt{msgget} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msgget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msgget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msgpack\_pack\_int}}{msgpack\_pack\_int}}\label{msgpack_pack_int}

\texttt{msgpack\_pack\_int} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msgpack\_pack\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msgpack\_pack\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msgpack\_pack\_str}}{msgpack\_pack\_str}}\label{msgpack_pack_str}

\texttt{msgpack\_pack\_str} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msgpack\_pack\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msgpack\_pack\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msgrcv}}{msgrcv}}\label{msgrcv}

\texttt{msgrcv} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msgrcv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msgrcv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msgsnd}}{msgsnd}}\label{msgsnd}

\texttt{msgsnd} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msgsnd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msgsnd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mshape}}{mshape}}\label{mshape}

\texttt{mshape} --- extended stdlib builtin. Alias for
\texttt{matrix\_shape}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mshape $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mshape |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msorted}}{msorted}}\label{msorted}

\texttt{msorted} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{merge\_sorted}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mst}}{mst}}\label{mst}

\texttt{prim\_mst} (aliases \texttt{mst}, \texttt{prim}) computes the
minimum spanning tree weight via Prim\textquotesingle s algorithm. Takes
an adjacency matrix.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p mst([[0,2,0],[2,0,3],[0,3,0]])  \# 5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mstat}}{mstat}}\label{mstat}

\texttt{mstat} --- extended stdlib builtin. Alias for
\texttt{mode\_stat}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mstat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mstat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msub}}{msub}}\label{msub}

\texttt{msub} --- extended stdlib builtin. Alias for
\texttt{matrix\_sub}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msum}}{msum}}\label{msum}

\texttt{msum} --- matrix operations (uncategorized batch) builtin. Alias
for \texttt{matrix\_sum}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = msum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map msum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{msun}}{msun}}\label{msun}

\texttt{sun\_mass} (alias \texttt{msun}) --- M☉ ≈ 1.989×10³⁰ kg. Mass of
Sun (solar mass).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p msun   \# 1.98892e30 kg}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mt19937\_temper}}{mt19937\_temper}}\label{mt19937_temper}

\texttt{mt19937\_temper} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mt19937\_temper $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mt19937\_temper |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mtf\_decode}}{mtf\_decode}}\label{mtf_decode}

\texttt{mtf\_decode} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mtf\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mtf\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mtf\_encode}}{mtf\_encode}}\label{mtf_encode}

\texttt{mtf\_encode} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mtf\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mtf\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mtime}}{mtime}}\label{mtime}

\texttt{mtime} --- file stat / path builtin. Alias for
\texttt{file\_mtime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mtime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mtime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mtrace}}{mtrace}}\label{mtrace}

\texttt{mtrace} --- extended stdlib builtin. Alias for
\texttt{matrix\_trace}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mtrace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mtrace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mtrans}}{mtrans}}\label{mtrans}

\texttt{mtrans} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{matrix\_transpose}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mtrans $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mtrans |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mu0}}{mu0}}\label{mu0}

\texttt{mu0} --- physics constants builtin. Alias for
\texttt{vacuum\_permeability}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mu0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mu0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mu\_law\_decode}}{mu\_law\_decode}}\label{mu_law_decode}

\texttt{mu\_law\_decode} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mu\_law\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mu\_law\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mu\_law\_encode}}{mu\_law\_encode}}\label{mu_law_encode}

\texttt{mu\_law\_encode} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mu\_law\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mu\_law\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mub}}{mub}}\label{mub}

\texttt{mub} --- physics constants builtin. Alias for
\texttt{bohr\_magneton}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{muller}}{muller}}\label{muller}

\texttt{muller} --- batch 19 builtin. Alias for \texttt{muller\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = muller $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map muller |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{muller\_root}}{muller\_root}}\label{muller_root}

\texttt{muller\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = muller\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map muller\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multi\_decrement\_q}}{multi\_decrement\_q}}\label{multi_decrement_q}

\texttt{multi\_decrement\_q} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multi\_decrement\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multi\_decrement\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multi\_knapsack\_step}}{multi\_knapsack\_step}}\label{multi_knapsack_step}

\texttt{multi\_knapsack\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multi\_knapsack\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multi\_knapsack\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multi\_state\_pij}}{multi\_state\_pij}}\label{multi_state_pij}

\texttt{multi\_state\_pij} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multi\_state\_pij $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multi\_state\_pij |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multidim\_packing\_step}}{multidim\_packing\_step}}\label{multidim_packing_step}

\texttt{multidim\_packing\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multidim\_packing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multidim\_packing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multinom}}{multinom}}\label{multinom}

\texttt{multinom} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{multinomial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multinom $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multinom |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multinomial}}{multinomial}}\label{multinomial}

\texttt{multinomial} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multinomial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multinomial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multinomial\_count}}{multinomial\_count}}\label{multinomial_count}

\texttt{multinomial\_count} --- batch 9 builtin. Alias for
\texttt{multiset\_permutations\_count}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multinomial\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multinomial\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multinomial\_logit\_prob}}{multinomial\_logit\_prob}}\label{multinomial_logit_prob}

\texttt{multinomial\_logit\_prob} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multinomial\_logit\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multinomial\_logit\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multiset\_difference}}{multiset\_difference}}\label{multiset_difference}

\texttt{multiset\_difference} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multiset\_difference $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multiset\_difference |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multiset\_intersection}}{multiset\_intersection}}\label{multiset_intersection}

\texttt{multiset\_intersection} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multiset\_intersection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multiset\_intersection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multiset\_permutations\_count}}{multiset\_permutations\_count}}\label{multiset_permutations_count}

\texttt{multiset\_permutations\_count} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multiset\_permutations\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multiset\_permutations\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{multiset\_union}}{multiset\_union}}\label{multiset_union}

\texttt{multiset\_union} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = multiset\_union $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map multiset\_union |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mun}}{mun}}\label{mun}

\texttt{mun} --- physics constants builtin. Alias for
\texttt{nuclear\_magneton}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mun $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mun |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{murmurhash3\_x32}}{murmurhash3\_x32}}\label{murmurhash3_x32}

\texttt{murmurhash3\_x32} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = murmurhash3\_x32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map murmurhash3\_x32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mutation\_bit\_flip\_prob}}{mutation\_bit\_flip\_prob}}\label{mutation_bit_flip_prob}

\texttt{mutation\_bit\_flip\_prob} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mutation\_bit\_flip\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mutation\_bit\_flip\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mutation\_rate}}{mutation\_rate}}\label{mutation_rate}

\texttt{mutation\_rate} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mutation\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mutation\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mutual\_information\_step}}{mutual\_information\_step}}\label{mutual_information_step}

\texttt{mutual\_information\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mutual\_information\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mutual\_information\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{myerson\_optimal}}{myerson\_optimal}}\label{myerson_optimal}

\texttt{myerson\_optimal} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = myerson\_optimal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map myerson\_optimal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{mzeros}}{mzeros}}\label{mzeros}

\texttt{mzeros} --- extended stdlib builtin. Alias for
\texttt{matrix\_zeros}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = mzeros $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map mzeros |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{n\_ball\_volume}}{n\_ball\_volume}}\label{n_ball_volume}

\texttt{n\_ball\_volume} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = n\_ball\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map n\_ball\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nanoid}}{nanoid}}\label{nanoid}

\texttt{nanoid} --- id helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nanoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nanoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nao\_index\_step}}{nao\_index\_step}}\label{nao_index_step}

\texttt{nao\_index\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nao\_index\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nao\_index\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nash\_bargaining\_solution}}{nash\_bargaining\_solution}}\label{nash_bargaining_solution}

\texttt{nash\_bargaining\_solution} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nash\_bargaining\_solution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nash\_bargaining\_solution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nash\_equilibrium\_pair}}{nash\_equilibrium\_pair}}\label{nash_equilibrium_pair}

\texttt{nash\_equilibrium\_pair} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nash\_equilibrium\_pair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nash\_equilibrium\_pair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nash\_social\_welfare}}{nash\_social\_welfare}}\label{nash_social_welfare}

\texttt{nash\_social\_welfare} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nash\_social\_welfare $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nash\_social\_welfare |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nato}}{nato}}\label{nato}

\texttt{nato} --- encoding / phonetics builtin. Alias for
\texttt{nato\_phonetic}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nato $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nato |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nato\_phonetic}}{nato\_phonetic}}\label{nato_phonetic}

\texttt{nato\_phonetic} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nato\_phonetic $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nb\_bernoulli\_likelihood}}{nb\_bernoulli\_likelihood}}\label{nb_bernoulli_likelihood}

\texttt{nb\_bernoulli\_likelihood} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nb\_bernoulli\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nb\_bernoulli\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nb\_gaussian\_likelihood}}{nb\_gaussian\_likelihood}}\label{nb_gaussian_likelihood}

\texttt{nb\_gaussian\_likelihood} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nb\_gaussian\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nb\_gaussian\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nb\_multinomial\_log\_likelihood}}{nb\_multinomial\_log\_likelihood}}\label{nb_multinomial_log_likelihood}

\texttt{nb\_multinomial\_log\_likelihood} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nb\_multinomial\_log\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nb\_multinomial\_log\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nbe\_normalize}}{nbe\_normalize}}\label{nbe_normalize}

\texttt{nbe\_normalize} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nbe\_normalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nbe\_normalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ncol}}{ncol}}\label{ncol}

\texttt{ncol} --- number of columns in a matrix.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ncol([[1,2,3],[4,5,6]])  \# 3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ndivs}}{ndivs}}\label{ndivs}

\texttt{ndivs} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{num\_divisors}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ndivs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ndivs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ne\_from\_variance}}{ne\_from\_variance}}\label{ne_from_variance}

\texttt{ne\_from\_variance} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ne\_from\_variance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ne\_from\_variance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nearest\_insertion\_step}}{nearest\_insertion\_step}}\label{nearest_insertion_step}

\texttt{nearest\_insertion\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nearest\_insertion\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nearest\_insertion\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nearest\_neighbor\_tour\_step}}{nearest\_neighbor\_tour\_step}}\label{nearest_neighbor_tour_step}

\texttt{nearest\_neighbor\_tour\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nearest\_neighbor\_tour\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nearest\_neighbor\_tour\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{necklace\_count}}{necklace\_count}}\label{necklace_count}

\texttt{necklace\_count} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = necklace\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map necklace\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{needleman\_wunsch\_score}}{needleman\_wunsch\_score}}\label{needleman_wunsch_score}

\texttt{needleman\_wunsch\_score} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = needleman\_wunsch\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map needleman\_wunsch\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{neg\_inf}}{neg\_inf}}\label{neg_inf}

\texttt{neg\_inf} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = neg\_inf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map neg\_inf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{neg\_n}}{neg\_n}}\label{neg_n}

\texttt{neg\_n} --- trivial numeric / predicate builtins builtin. Alias
for \texttt{negative}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = neg\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map neg\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{negate}}{negate}}\label{negate}

\texttt{negate} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = negate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map negate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{negate\_each}}{negate\_each}}\label{negate_each}

\texttt{negate\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = negate\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map negate\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{negative}}{negative}}\label{negative}

\texttt{negative} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = negative $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map negative |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nei\_genetic\_distance}}{nei\_genetic\_distance}}\label{nei_genetic_distance}

\texttt{nei\_genetic\_distance} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nei\_genetic\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nei\_genetic\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{neither}}{neither}}\label{neither}

\texttt{neither} --- boolean combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = neither $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map neither |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nelder\_mead\_contract}}{nelder\_mead\_contract}}\label{nelder_mead_contract}

\texttt{nelder\_mead\_contract} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nelder\_mead\_contract $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nelder\_mead\_contract |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nelder\_mead\_expand}}{nelder\_mead\_expand}}\label{nelder_mead_expand}

\texttt{nelder\_mead\_expand} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nelder\_mead\_expand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nelder\_mead\_expand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nelder\_mead\_reflect}}{nelder\_mead\_reflect}}\label{nelder_mead_reflect}

\texttt{nelder\_mead\_reflect} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nelder\_mead\_reflect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nelder\_mead\_reflect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nemhauser\_wolsey\_bound}}{nemhauser\_wolsey\_bound}}\label{nemhauser_wolsey_bound}

\texttt{nemhauser\_wolsey\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nemhauser\_wolsey\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nemhauser\_wolsey\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ner\_bilou\_decode}}{ner\_bilou\_decode}}\label{ner_bilou_decode}

\texttt{ner\_bilou\_decode} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ner\_bilou\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ner\_bilou\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nernst\_diffusion\_layer}}{nernst\_diffusion\_layer}}\label{nernst_diffusion_layer}

\texttt{nernst\_diffusion\_layer} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nernst\_diffusion\_layer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nernst\_diffusion\_layer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nernst\_einstein\_diffusivity}}{nernst\_einstein\_diffusivity}}\label{nernst_einstein_diffusivity}

\texttt{nernst\_einstein\_diffusivity} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nernst\_einstein\_diffusivity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nernst\_einstein\_diffusivity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nernst\_planck\_flux}}{nernst\_planck\_flux}}\label{nernst_planck_flux}

\texttt{nernst\_planck\_flux} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nernst\_planck\_flux $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nernst\_planck\_flux |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nernst\_potential\_full}}{nernst\_potential\_full}}\label{nernst_potential_full}

\texttt{nernst\_potential\_full} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nernst\_potential\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nernst\_potential\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nerve\_complex\_count}}{nerve\_complex\_count}}\label{nerve_complex_count}

\texttt{nerve\_complex\_count} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nerve\_complex\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nerve\_complex\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nesterov\_accelerate\_step}}{nesterov\_accelerate\_step}}\label{nesterov_accelerate_step}

\texttt{nesterov\_accelerate\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nesterov\_accelerate\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nesterov\_accelerate\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nesterov\_step}}{nesterov\_step}}\label{nesterov_step}

\texttt{nesterov\_step} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nesterov\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nesterov\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aiad\_step}}{net\_aiad\_step}}\label{net_aiad_step}

\texttt{net\_aiad\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aiad\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aiad\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aimd\_step}}{net\_aimd\_step}}\label{net_aimd_step}

\texttt{net\_aimd\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aimd\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aimd\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_alohanet\_throughput}}{net\_alohanet\_throughput}}\label{net_alohanet_throughput}

\texttt{net\_alohanet\_throughput} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_alohanet\_throughput $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_alohanet\_throughput |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_alpha\_fair\_step}}{net\_alpha\_fair\_step}}\label{net_alpha_fair_step}

\texttt{net\_alpha\_fair\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_alpha\_fair\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_alpha\_fair\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_amc\_threshold\_index}}{net\_amc\_threshold\_index}}\label{net_amc_threshold_index}

\texttt{net\_amc\_threshold\_index} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_amc\_threshold\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_amc\_threshold\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_blue\_step}}{net\_aqm\_blue\_step}}\label{net_aqm_blue_step}

\texttt{net\_aqm\_blue\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_blue\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_blue\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_choke\_step}}{net\_aqm\_choke\_step}}\label{net_aqm_choke_step}

\texttt{net\_aqm\_choke\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_choke\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_choke\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_codel\_target}}{net\_aqm\_codel\_target}}\label{net_aqm_codel_target}

\texttt{net\_aqm\_codel\_target} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_codel\_target $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_codel\_target |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_drr\_step}}{net\_aqm\_drr\_step}}\label{net_aqm_drr_step}

\texttt{net\_aqm\_drr\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_drr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_drr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_fq\_codel\_step}}{net\_aqm\_fq\_codel\_step}}\label{net_aqm_fq_codel_step}

\texttt{net\_aqm\_fq\_codel\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_fq\_codel\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_fq\_codel\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_pie\_drop\_rate}}{net\_aqm\_pie\_drop\_rate}}\label{net_aqm_pie_drop_rate}

\texttt{net\_aqm\_pie\_drop\_rate} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_pie\_drop\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_pie\_drop\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_red\_drop\_prob}}{net\_aqm\_red\_drop\_prob}}\label{net_aqm_red_drop_prob}

\texttt{net\_aqm\_red\_drop\_prob} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_red\_drop\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_red\_drop\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_sfq\_step}}{net\_aqm\_sfq\_step}}\label{net_aqm_sfq_step}

\texttt{net\_aqm\_sfq\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_sfq\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_sfq\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_aqm\_wrr\_step}}{net\_aqm\_wrr\_step}}\label{net_aqm_wrr_step}

\texttt{net\_aqm\_wrr\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_aqm\_wrr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_aqm\_wrr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_array\_gain}}{net\_array\_gain}}\label{net_array_gain}

\texttt{net\_array\_gain} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_array\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_array\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_backpressure\_step}}{net\_backpressure\_step}}\label{net_backpressure_step}

\texttt{net\_backpressure\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_backpressure\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_backpressure\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_bandwidth\_delay\_product}}{net\_bandwidth\_delay\_product}}\label{net_bandwidth_delay_product}

\texttt{net\_bandwidth\_delay\_product} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_bandwidth\_delay\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_bandwidth\_delay\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_bcjr\_step}}{net\_bcjr\_step}}\label{net_bcjr_step}

\texttt{net\_bcjr\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_bcjr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_bcjr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_blocking\_probability}}{net\_blocking\_probability}}\label{net_blocking_probability}

\texttt{net\_blocking\_probability} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_blocking\_probability $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_blocking\_probability |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_burst\_size\_compute}}{net\_burst\_size\_compute}}\label{net_burst_size_compute}

\texttt{net\_burst\_size\_compute} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_burst\_size\_compute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_burst\_size\_compute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_call\_admission\_check}}{net\_call\_admission\_check}}\label{net_call_admission_check}

\texttt{net\_call\_admission\_check} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_call\_admission\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_call\_admission\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_capacity\_shannon}}{net\_capacity\_shannon}}\label{net_capacity_shannon}

\texttt{net\_capacity\_shannon} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_capacity\_shannon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_capacity\_shannon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_coding\_gain}}{net\_coding\_gain}}\label{net_coding_gain}

\texttt{net\_coding\_gain} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_coding\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_coding\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_csma\_back\_off}}{net\_csma\_back\_off}}\label{net_csma_back_off}

\texttt{net\_csma\_back\_off} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_csma\_back\_off $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_csma\_back\_off |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_csma\_efficiency}}{net\_csma\_efficiency}}\label{net_csma_efficiency}

\texttt{net\_csma\_efficiency} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_csma\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_csma\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_diversity\_gain}}{net\_diversity\_gain}}\label{net_diversity_gain}

\texttt{net\_diversity\_gain} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_diversity\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_diversity\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_doppler\_shift}}{net\_doppler\_shift}}\label{net_doppler_shift}

\texttt{net\_doppler\_shift} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_doppler\_shift $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_doppler\_shift |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_drop\_tail\_check}}{net\_drop\_tail\_check}}\label{net_drop_tail_check}

\texttt{net\_drop\_tail\_check} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_drop\_tail\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_drop\_tail\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_engset\_formula}}{net\_engset\_formula}}\label{net_engset_formula}

\texttt{net\_engset\_formula} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_engset\_formula $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_engset\_formula |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_erlang\_b\_formula}}{net\_erlang\_b\_formula}}\label{net_erlang_b_formula}

\texttt{net\_erlang\_b\_formula} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_erlang\_b\_formula $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_erlang\_b\_formula |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_erlang\_c\_formula}}{net\_erlang\_c\_formula}}\label{net_erlang_c_formula}

\texttt{net\_erlang\_c\_formula} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_erlang\_c\_formula $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_erlang\_c\_formula |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_forced\_flow\_law}}{net\_forced\_flow\_law}}\label{net_forced_flow_law}

\texttt{net\_forced\_flow\_law} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_forced\_flow\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_forced\_flow\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_friis\_received\_power}}{net\_friis\_received\_power}}\label{net_friis_received_power}

\texttt{net\_friis\_received\_power} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_friis\_received\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_friis\_received\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_handoff\_threshold}}{net\_handoff\_threshold}}\label{net_handoff_threshold}

\texttt{net\_handoff\_threshold} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_handoff\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_handoff\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_harq\_combining\_gain}}{net\_harq\_combining\_gain}}\label{net_harq_combining_gain}

\texttt{net\_harq\_combining\_gain} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_harq\_combining\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_harq\_combining\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_jitter\_estimate}}{net\_jitter\_estimate}}\label{net_jitter_estimate}

\texttt{net\_jitter\_estimate} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_jitter\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_jitter\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_kelly\_pricing\_step}}{net\_kelly\_pricing\_step}}\label{net_kelly_pricing_step}

\texttt{net\_kelly\_pricing\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_kelly\_pricing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_kelly\_pricing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_latency\_avg}}{net\_latency\_avg}}\label{net_latency_avg}

\texttt{net\_latency\_avg} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_latency\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_latency\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_ldpc\_iteration\_step}}{net\_ldpc\_iteration\_step}}\label{net_ldpc_iteration_step}

\texttt{net\_ldpc\_iteration\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_ldpc\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_ldpc\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_link\_capacity\_share}}{net\_link\_capacity\_share}}\label{net_link_capacity_share}

\texttt{net\_link\_capacity\_share} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_link\_capacity\_share $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_link\_capacity\_share |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_little\_law\_l}}{net\_little\_law\_l}}\label{net_little_law_l}

\texttt{net\_little\_law\_l} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_little\_law\_l $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_little\_law\_l |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_log\_distance\_path}}{net\_log\_distance\_path}}\label{net_log_distance_path}

\texttt{net\_log\_distance\_path} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_log\_distance\_path $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_log\_distance\_path |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_loss\_rate\_to\_throughput}}{net\_loss\_rate\_to\_throughput}}\label{net_loss_rate_to_throughput}

\texttt{net\_loss\_rate\_to\_throughput} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_loss\_rate\_to\_throughput $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_lyapunov\_drift\_plus\_penalty}}{net\_lyapunov\_drift\_plus\_penalty}}\label{net_lyapunov_drift_plus_penalty}

\texttt{net\_lyapunov\_drift\_plus\_penalty} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_lyapunov\_drift\_plus\_penalty $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_lyapunov\_drift\_plus\_penalty |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_macro\_diversity\_step}}{net\_macro\_diversity\_step}}\label{net_macro_diversity_step}

\texttt{net\_macro\_diversity\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_macro\_diversity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_macro\_diversity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_max\_min\_fair\_step}}{net\_max\_min\_fair\_step}}\label{net_max_min_fair_step}

\texttt{net\_max\_min\_fair\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_max\_min\_fair\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_max\_min\_fair\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_max\_weight\_match}}{net\_max\_weight\_match}}\label{net_max_weight_match}

\texttt{net\_max\_weight\_match} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_max\_weight\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_max\_weight\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_miad\_step}}{net\_miad\_step}}\label{net_miad_step}

\texttt{net\_miad\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_miad\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_miad\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_micro\_diversity\_step}}{net\_micro\_diversity\_step}}\label{net_micro_diversity_step}

\texttt{net\_micro\_diversity\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_micro\_diversity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_micro\_diversity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_mimd\_step}}{net\_mimd\_step}}\label{net_mimd_step}

\texttt{net\_mimd\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_mimd\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_mimd\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_mimo\_capacity\_step}}{net\_mimo\_capacity\_step}}\label{net_mimo_capacity_step}

\texttt{net\_mimo\_capacity\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_mimo\_capacity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_mimo\_capacity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_mmse\_beam\_step}}{net\_mmse\_beam\_step}}\label{net_mmse_beam_step}

\texttt{net\_mmse\_beam\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_mmse\_beam\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_mmse\_beam\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_multiplexing\_gain}}{net\_multiplexing\_gain}}\label{net_multiplexing_gain}

\texttt{net\_multiplexing\_gain} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_multiplexing\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_multiplexing\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_network\_utility\_max}}{net\_network\_utility\_max}}\label{net_network_utility_max}

\texttt{net\_network\_utility\_max} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_network\_utility\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_network\_utility\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_okumura\_hata\_loss}}{net\_okumura\_hata\_loss}}\label{net_okumura_hata_loss}

\texttt{net\_okumura\_hata\_loss} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_okumura\_hata\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_okumura\_hata\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_outage\_probability}}{net\_outage\_probability}}\label{net_outage_probability}

\texttt{net\_outage\_probability} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_outage\_probability $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_outage\_probability |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_packet\_loss\_estimate}}{net\_packet\_loss\_estimate}}\label{net_packet_loss_estimate}

\texttt{net\_packet\_loss\_estimate} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_packet\_loss\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_packet\_loss\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_packet\_pacing\_step}}{net\_packet\_pacing\_step}}\label{net_packet_pacing_step}

\texttt{net\_packet\_pacing\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_packet\_pacing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_packet\_pacing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_path\_capacity\_kleinrock}}{net\_path\_capacity\_kleinrock}}\label{net_path_capacity_kleinrock}

\texttt{net\_path\_capacity\_kleinrock} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_path\_capacity\_kleinrock $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_path\_capacity\_kleinrock |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_polar\_decode\_step}}{net\_polar\_decode\_step}}\label{net_polar_decode_step}

\texttt{net\_polar\_decode\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_polar\_decode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_polar\_decode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_polling\_efficiency}}{net\_polling\_efficiency}}\label{net_polling_efficiency}

\texttt{net\_polling\_efficiency} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_polling\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_polling\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_priority\_queue\_index}}{net\_priority\_queue\_index}}\label{net_priority_queue_index}

\texttt{net\_priority\_queue\_index} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_priority\_queue\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_priority\_queue\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_proportional\_fair\_share}}{net\_proportional\_fair\_share}}\label{net_proportional_fair_share}

\texttt{net\_proportional\_fair\_share} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_proportional\_fair\_share $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_proportional\_fair\_share |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_pruning\_gain}}{net\_pruning\_gain}}\label{net_pruning_gain}

\texttt{net\_pruning\_gain} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_pruning\_gain $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_pruning\_gain |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_qcsma\_propose}}{net\_qcsma\_propose}}\label{net_qcsma_propose}

\texttt{net\_qcsma\_propose} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_qcsma\_propose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_qcsma\_propose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_radio\_path\_loss}}{net\_radio\_path\_loss}}\label{net_radio_path_loss}

\texttt{net\_radio\_path\_loss} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_radio\_path\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_radio\_path\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_rayleigh\_envelope}}{net\_rayleigh\_envelope}}\label{net_rayleigh_envelope}

\texttt{net\_rayleigh\_envelope} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_rayleigh\_envelope $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_rayleigh\_envelope |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_reproductive\_rate}}{net\_reproductive\_rate}}\label{net_reproductive_rate}

\texttt{net\_reproductive\_rate} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_reproductive\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_reproductive\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_response\_time\_law}}{net\_response\_time\_law}}\label{net_response_time_law}

\texttt{net\_response\_time\_law} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_response\_time\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_response\_time\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_rician\_k\_factor}}{net\_rician\_k\_factor}}\label{net_rician_k_factor}

\texttt{net\_rician\_k\_factor} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_rician\_k\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_rician\_k\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_router\_buffer\_size}}{net\_router\_buffer\_size}}\label{net_router_buffer_size}

\texttt{net\_router\_buffer\_size} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_router\_buffer\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_router\_buffer\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_rto\_compute}}{net\_rto\_compute}}\label{net_rto_compute}

\texttt{net\_rto\_compute} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_rto\_compute $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_rtt\_smoothed}}{net\_rtt\_smoothed}}\label{net_rtt_smoothed}

\texttt{net\_rtt\_smoothed} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_rtt\_smoothed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_rtt\_smoothed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_rtt\_variation}}{net\_rtt\_variation}}\label{net_rtt_variation}

\texttt{net\_rtt\_variation} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_rtt\_variation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_rtt\_variation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_shadowing\_normal}}{net\_shadowing\_normal}}\label{net_shadowing_normal}

\texttt{net\_shadowing\_normal} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_shadowing\_normal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_shadowing\_normal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_slotted\_aloha\_throughput}}{net\_slotted\_aloha\_throughput}}\label{net_slotted_aloha_throughput}

\texttt{net\_slotted\_aloha\_throughput} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_slotted\_aloha\_throughput $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_slotted\_aloha\_throughput |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_bbr\_step}}{net\_tcp\_bbr\_step}}\label{net_tcp_bbr_step}

\texttt{net\_tcp\_bbr\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_bbr\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_bbr\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_compound\_step}}{net\_tcp\_compound\_step}}\label{net_tcp_compound_step}

\texttt{net\_tcp\_compound\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_compound\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_compound\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_cubic\_step}}{net\_tcp\_cubic\_step}}\label{net_tcp_cubic_step}

\texttt{net\_tcp\_cubic\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_cubic\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_cubic\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_cwnd\_step}}{net\_tcp\_cwnd\_step}}\label{net_tcp_cwnd_step}

\texttt{net\_tcp\_cwnd\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_cwnd\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_cwnd\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_dctcp\_step}}{net\_tcp\_dctcp\_step}}\label{net_tcp_dctcp_step}

\texttt{net\_tcp\_dctcp\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_dctcp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_dctcp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_htcp\_step}}{net\_tcp\_htcp\_step}}\label{net_tcp_htcp_step}

\texttt{net\_tcp\_htcp\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_htcp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_htcp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_hybla\_step}}{net\_tcp\_hybla\_step}}\label{net_tcp_hybla_step}

\texttt{net\_tcp\_hybla\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_hybla\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_hybla\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_illinois\_step}}{net\_tcp\_illinois\_step}}\label{net_tcp_illinois_step}

\texttt{net\_tcp\_illinois\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_illinois\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_illinois\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_lp\_step}}{net\_tcp\_lp\_step}}\label{net_tcp_lp_step}

\texttt{net\_tcp\_lp\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_lp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_lp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_reno\_step}}{net\_tcp\_reno\_step}}\label{net_tcp_reno_step}

\texttt{net\_tcp\_reno\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_reno\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_reno\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_scalable\_step}}{net\_tcp\_scalable\_step}}\label{net_tcp_scalable_step}

\texttt{net\_tcp\_scalable\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_scalable\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_scalable\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_ssthresh\_update}}{net\_tcp\_ssthresh\_update}}\label{net_tcp_ssthresh_update}

\texttt{net\_tcp\_ssthresh\_update} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_ssthresh\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_ssthresh\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_vegas\_step}}{net\_tcp\_vegas\_step}}\label{net_tcp_vegas_step}

\texttt{net\_tcp\_vegas\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_vegas\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_vegas\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_veno\_step}}{net\_tcp\_veno\_step}}\label{net_tcp_veno_step}

\texttt{net\_tcp\_veno\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_veno\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_veno\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_westwood\_step}}{net\_tcp\_westwood\_step}}\label{net_tcp_westwood_step}

\texttt{net\_tcp\_westwood\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_westwood\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_westwood\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_tcp\_yeah\_step}}{net\_tcp\_yeah\_step}}\label{net_tcp_yeah_step}

\texttt{net\_tcp\_yeah\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_tcp\_yeah\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_tcp\_yeah\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_throughput\_law}}{net\_throughput\_law}}\label{net_throughput_law}

\texttt{net\_throughput\_law} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_throughput\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_throughput\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_throughput\_mathis}}{net\_throughput\_mathis}}\label{net_throughput_mathis}

\texttt{net\_throughput\_mathis} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_throughput\_mathis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_throughput\_mathis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_throughput\_padhye}}{net\_throughput\_padhye}}\label{net_throughput_padhye}

\texttt{net\_throughput\_padhye} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_throughput\_padhye $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_throughput\_padhye |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_throughput\_response}}{net\_throughput\_response}}\label{net_throughput_response}

\texttt{net\_throughput\_response} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_throughput\_response $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_throughput\_response |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_token\_rate\_limit}}{net\_token\_rate\_limit}}\label{net_token_rate_limit}

\texttt{net\_token\_rate\_limit} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_token\_rate\_limit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_token\_rate\_limit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_token\_ring\_efficiency}}{net\_token\_ring\_efficiency}}\label{net_token_ring_efficiency}

\texttt{net\_token\_ring\_efficiency} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_token\_ring\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_token\_ring\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_traffic\_shaper\_step}}{net\_traffic\_shaper\_step}}\label{net_traffic_shaper_step}

\texttt{net\_traffic\_shaper\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_traffic\_shaper\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_traffic\_shaper\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_turbo\_decode\_iter}}{net\_turbo\_decode\_iter}}\label{net_turbo_decode_iter}

\texttt{net\_turbo\_decode\_iter} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_turbo\_decode\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_turbo\_decode\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_two\_ray\_ground\_loss}}{net\_two\_ray\_ground\_loss}}\label{net_two_ray_ground_loss}

\texttt{net\_two\_ray\_ground\_loss} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_two\_ray\_ground\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_two\_ray\_ground\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_utilization\_law}}{net\_utilization\_law}}\label{net_utilization_law}

\texttt{net\_utilization\_law} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_utilization\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_utilization\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_viterbi\_step}}{net\_viterbi\_step}}\label{net_viterbi_step}

\texttt{net\_viterbi\_step} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_viterbi\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_viterbi\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_water\_filling\_power}}{net\_water\_filling\_power}}\label{net_water_filling_power}

\texttt{net\_water\_filling\_power} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_water\_filling\_power $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_water\_filling\_power |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{net\_zero\_forcing\_beam}}{net\_zero\_forcing\_beam}}\label{net_zero_forcing_beam}

\texttt{net\_zero\_forcing\_beam} --- batch 49 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = net\_zero\_forcing\_beam $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map net\_zero\_forcing\_beam |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{network\_formation\_step}}{network\_formation\_step}}\label{network_formation_step}

\texttt{network\_formation\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = network\_formation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map network\_formation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{neutron\_mass}}{neutron\_mass}}\label{neutron_mass}

\texttt{neutron\_mass} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = neutron\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map neutron\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{newey\_west\_se}}{newey\_west\_se}}\label{newey_west_se}

\texttt{newey\_west\_se} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = newey\_west\_se $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map newey\_west\_se |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{newmark\_beta\_step}}{newmark\_beta\_step}}\label{newmark_beta_step}

\texttt{newmark\_beta\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = newmark\_beta\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map newmark\_beta\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{newton}}{newton}}\label{newton}

\texttt{newton\_method} (aliases \texttt{newton},
\texttt{newton\_raphson}) finds a root via Newton-Raphson. Takes f,
f\textquotesingle, x0, and optional tolerance.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $root = newton(fn \{ $\_[0]**2 {-} 2 \}, fn \{ 2*$\_[0] \}, 1.5)  \# √2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{newtons\_to\_lbf}}{newtons\_to\_lbf}}\label{newtons_to_lbf}

\texttt{newtons\_to\_lbf} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = newtons\_to\_lbf $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{next\_permutation}}{next\_permutation}}\label{next_permutation}

\texttt{next\_permutation} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = next\_permutation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map next\_permutation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{next\_prime}}{next\_prime}}\label{next_prime}

\texttt{next\_prime} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = next\_prime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map next\_prime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nfa\_to\_dfa}}{nfa\_to\_dfa}}\label{nfa_to_dfa}

\texttt{nfa\_to\_dfa} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nfa\_to\_dfa $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nfirst}}{nfirst}}\label{nfirst}

\texttt{nfirst} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nfirst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nfirst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nfs}}{nfs}}\label{nfs}

\texttt{nfs} --- algebraic match builtin. Alias for \texttt{nfirst}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ngram}}{ngram}}\label{ngram}

\texttt{ngram} --- string processing (uncategorized batch) builtin.
Alias for \texttt{ngrams}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ngram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ngram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ngrams}}{ngrams}}\label{ngrams}

\texttt{ngrams} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ngrams $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ngrams |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nichols\_chart\_step}}{nichols\_chart\_step}}\label{nichols_chart_step}

\texttt{nichols\_chart\_step} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nichols\_chart\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nichols\_chart\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nilpotency\_class\_lower}}{nilpotency\_class\_lower}}\label{nilpotency_class_lower}

\texttt{nilpotency\_class\_lower} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nilpotency\_class\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nilpotency\_class\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_alibi\_position\_bias}}{nlp\_alibi\_position\_bias}}\label{nlp_alibi_position_bias}

\texttt{nlp\_alibi\_position\_bias} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_alibi\_position\_bias $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_alibi\_position\_bias |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_attention\_pool\_step}}{nlp\_attention\_pool\_step}}\label{nlp_attention_pool_step}

\texttt{nlp\_attention\_pool\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_attention\_pool\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_attention\_pool\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_avg\_pool\_step}}{nlp\_avg\_pool\_step}}\label{nlp_avg_pool_step}

\texttt{nlp\_avg\_pool\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_avg\_pool\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_avg\_pool\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_bigbird\_step}}{nlp\_bigbird\_step}}\label{nlp_bigbird_step}

\texttt{nlp\_bigbird\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_bigbird\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_bigbird\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_bits\_per\_character}}{nlp\_bits\_per\_character}}\label{nlp_bits_per_character}

\texttt{nlp\_bits\_per\_character} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_bits\_per\_character $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_bits\_per\_character |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_bleu\_score\_n}}{nlp\_bleu\_score\_n}}\label{nlp_bleu_score_n}

\texttt{nlp\_bleu\_score\_n} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_bleu\_score\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_bleu\_score\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_block\_attn\_step}}{nlp\_block\_attn\_step}}\label{nlp_block_attn_step}

\texttt{nlp\_block\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_block\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_block\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_bm25\_score}}{nlp\_bm25\_score}}\label{nlp_bm25_score}

\texttt{nlp\_bm25\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_bm25\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_bm25\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_byte\_frequency}}{nlp\_byte\_frequency}}\label{nlp_byte_frequency}

\texttt{nlp\_byte\_frequency} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_byte\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_byte\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_byte\_level\_bpe\_step}}{nlp\_byte\_level\_bpe\_step}}\label{nlp_byte_level_bpe_step}

\texttt{nlp\_byte\_level\_bpe\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_byte\_level\_bpe\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_byte\_level\_bpe\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_byte\_pair\_merge\_step}}{nlp\_byte\_pair\_merge\_step}}\label{nlp_byte_pair_merge_step}

\texttt{nlp\_byte\_pair\_merge\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_byte\_pair\_merge\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_byte\_pair\_merge\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_cer\_score}}{nlp\_cer\_score}}\label{nlp_cer_score}

\texttt{nlp\_cer\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_cer\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_cer\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_char\_frequency}}{nlp\_char\_frequency}}\label{nlp_char_frequency}

\texttt{nlp\_char\_frequency} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_char\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_char\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_char\_ngram\_count}}{nlp\_char\_ngram\_count}}\label{nlp_char_ngram_count}

\texttt{nlp\_char\_ngram\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_char\_ngram\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_char\_ngram\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_chi2\_collocation}}{nlp\_chi2\_collocation}}\label{nlp_chi2_collocation}

\texttt{nlp\_chi2\_collocation} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_chi2\_collocation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_chi2\_collocation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_chrf\_score}}{nlp\_chrf\_score}}\label{nlp_chrf_score}

\texttt{nlp\_chrf\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_chrf\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_chrf\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_cosine\_similarity\_two}}{nlp\_cosine\_similarity\_two}}\label{nlp_cosine_similarity_two}

\texttt{nlp\_cosine\_similarity\_two} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_cosine\_similarity\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_cosine\_similarity\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_cross\_attn\_compute\_step}}{nlp\_cross\_attn\_compute\_step}}\label{nlp_cross_attn_compute_step}

\texttt{nlp\_cross\_attn\_compute\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_cross\_attn\_compute\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_cross\_attn\_compute\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_damerau\_levenshtein}}{nlp\_damerau\_levenshtein}}\label{nlp_damerau_levenshtein}

\texttt{nlp\_damerau\_levenshtein} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_damerau\_levenshtein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_damerau\_levenshtein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_dice\_coefficient\_two}}{nlp\_dice\_coefficient\_two}}\label{nlp_dice_coefficient_two}

\texttt{nlp\_dice\_coefficient\_two} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_dice\_coefficient\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_dice\_coefficient\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_digit\_ratio}}{nlp\_digit\_ratio}}\label{nlp_digit_ratio}

\texttt{nlp\_digit\_ratio} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_digit\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_digit\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_dilated\_attn\_step}}{nlp\_dilated\_attn\_step}}\label{nlp_dilated_attn_step}

\texttt{nlp\_dilated\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_dilated\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_dilated\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_dirichlet\_smoothing}}{nlp\_dirichlet\_smoothing}}\label{nlp_dirichlet_smoothing}

\texttt{nlp\_dirichlet\_smoothing} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_dirichlet\_smoothing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_dirichlet\_smoothing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_doc\_embedding\_avg}}{nlp\_doc\_embedding\_avg}}\label{nlp_doc_embedding_avg}

\texttt{nlp\_doc\_embedding\_avg} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_doc\_embedding\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_doc\_embedding\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_doc\_freq\_step}}{nlp\_doc\_freq\_step}}\label{nlp_doc_freq_step}

\texttt{nlp\_doc\_freq\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_doc\_freq\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_doc\_freq\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_dunning\_log\_likelihood}}{nlp\_dunning\_log\_likelihood}}\label{nlp_dunning_log_likelihood}

\texttt{nlp\_dunning\_log\_likelihood} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_dunning\_log\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_dunning\_log\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_email\_count}}{nlp\_email\_count}}\label{nlp_email_count}

\texttt{nlp\_email\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_email\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_email\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_emoji\_ratio}}{nlp\_emoji\_ratio}}\label{nlp_emoji_ratio}

\texttt{nlp\_emoji\_ratio} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_emoji\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_emoji\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_fasttext\_subword\_count}}{nlp\_fasttext\_subword\_count}}\label{nlp_fasttext_subword_count}

\texttt{nlp\_fasttext\_subword\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_fasttext\_subword\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_fasttext\_subword\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_global\_attn\_step}}{nlp\_global\_attn\_step}}\label{nlp_global_attn_step}

\texttt{nlp\_global\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_global\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_global\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_glove\_loss\_step}}{nlp\_glove\_loss\_step}}\label{nlp_glove_loss_step}

\texttt{nlp\_glove\_loss\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_glove\_loss\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_glove\_loss\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_good\_turing\_count}}{nlp\_good\_turing\_count}}\label{nlp_good_turing_count}

\texttt{nlp\_good\_turing\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_good\_turing\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_good\_turing\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_hamming\_distance}}{nlp\_hamming\_distance}}\label{nlp_hamming_distance}

\texttt{nlp\_hamming\_distance} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_hamming\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_hamming\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_hashtag\_count}}{nlp\_hashtag\_count}}\label{nlp_hashtag_count}

\texttt{nlp\_hashtag\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_hashtag\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_hashtag\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_inverse\_doc\_freq}}{nlp\_inverse\_doc\_freq}}\label{nlp_inverse_doc_freq}

\texttt{nlp\_inverse\_doc\_freq} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_inverse\_doc\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_inverse\_doc\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_jaccard\_similarity\_two}}{nlp\_jaccard\_similarity\_two}}\label{nlp_jaccard_similarity_two}

\texttt{nlp\_jaccard\_similarity\_two} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_jaccard\_similarity\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_jaccard\_similarity\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_jaro\_distance}}{nlp\_jaro\_distance}}\label{nlp_jaro_distance}

\texttt{nlp\_jaro\_distance} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_jaro\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_jaro\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_jaro\_winkler}}{nlp\_jaro\_winkler}}\label{nlp_jaro_winkler}

\texttt{nlp\_jaro\_winkler} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_jaro\_winkler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_jaro\_winkler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_jelinek\_mercer}}{nlp\_jelinek\_mercer}}\label{nlp_jelinek_mercer}

\texttt{nlp\_jelinek\_mercer} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_jelinek\_mercer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_jelinek\_mercer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_kl\_lm\_div}}{nlp\_kl\_lm\_div}}\label{nlp_kl_lm_div}

\texttt{nlp\_kl\_lm\_div} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_kl\_lm\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_kl\_lm\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_kneser\_ney\_step}}{nlp\_kneser\_ney\_step}}\label{nlp_kneser_ney_step}

\texttt{nlp\_kneser\_ney\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_kneser\_ney\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_kneser\_ney\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_laplace\_smoothing}}{nlp\_laplace\_smoothing}}\label{nlp_laplace_smoothing}

\texttt{nlp\_laplace\_smoothing} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_laplace\_smoothing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_laplace\_smoothing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_lcs\_length}}{nlp\_lcs\_length}}\label{nlp_lcs_length}

\texttt{nlp\_lcs\_length} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_lcs\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_lcs\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_lcs\_ratio}}{nlp\_lcs\_ratio}}\label{nlp_lcs_ratio}

\texttt{nlp\_lcs\_ratio} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_lcs\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_lcs\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_lda\_alpha\_step}}{nlp\_lda\_alpha\_step}}\label{nlp_lda_alpha_step}

\texttt{nlp\_lda\_alpha\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_lda\_alpha\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_lda\_alpha\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_lda\_beta\_step}}{nlp\_lda\_beta\_step}}\label{nlp_lda_beta_step}

\texttt{nlp\_lda\_beta\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_lda\_beta\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_lda\_beta\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_lda\_topic\_dist}}{nlp\_lda\_topic\_dist}}\label{nlp_lda_topic_dist}

\texttt{nlp\_lda\_topic\_dist} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_lda\_topic\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_lda\_topic\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_levenshtein\_dist}}{nlp\_levenshtein\_dist}}\label{nlp_levenshtein_dist}

\texttt{nlp\_levenshtein\_dist} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_levenshtein\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_levenshtein\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_lidstone\_smoothing}}{nlp\_lidstone\_smoothing}}\label{nlp_lidstone_smoothing}

\texttt{nlp\_lidstone\_smoothing} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_lidstone\_smoothing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_lidstone\_smoothing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_linformer\_step}}{nlp\_linformer\_step}}\label{nlp_linformer_step}

\texttt{nlp\_linformer\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_linformer\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_linformer\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_local\_attn\_step}}{nlp\_local\_attn\_step}}\label{nlp_local_attn_step}

\texttt{nlp\_local\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_local\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_local\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_loglikelihood\_collocation}}{nlp\_loglikelihood\_collocation}}\label{nlp_loglikelihood_collocation}

\texttt{nlp\_loglikelihood\_collocation} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_loglikelihood\_collocation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_loglikelihood\_collocation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_longformer\_step}}{nlp\_longformer\_step}}\label{nlp_longformer_step}

\texttt{nlp\_longformer\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_longformer\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_longformer\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_max\_pool\_step}}{nlp\_max\_pool\_step}}\label{nlp_max_pool_step}

\texttt{nlp\_max\_pool\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_max\_pool\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_max\_pool\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_max\_seq\_len\_check}}{nlp\_max\_seq\_len\_check}}\label{nlp_max_seq_len_check}

\texttt{nlp\_max\_seq\_len\_check} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_max\_seq\_len\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_max\_seq\_len\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_mention\_count}}{nlp\_mention\_count}}\label{nlp_mention_count}

\texttt{nlp\_mention\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_mention\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_mention\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_meteor\_score}}{nlp\_meteor\_score}}\label{nlp_meteor_score}

\texttt{nlp\_meteor\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_meteor\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_meteor\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_npmi\_score}}{nlp\_npmi\_score}}\label{nlp_npmi_score}

\texttt{nlp\_npmi\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_npmi\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_npmi\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_okapi\_score}}{nlp\_okapi\_score}}\label{nlp_okapi_score}

\texttt{nlp\_okapi\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_okapi\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_okapi\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_overlap\_coefficient}}{nlp\_overlap\_coefficient}}\label{nlp_overlap_coefficient}

\texttt{nlp\_overlap\_coefficient} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_overlap\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_overlap\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_pe\_freq\_band}}{nlp\_pe\_freq\_band}}\label{nlp_pe_freq_band}

\texttt{nlp\_pe\_freq\_band} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_pe\_freq\_band $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_pe\_freq\_band |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_performer\_step}}{nlp\_performer\_step}}\label{nlp_performer_step}

\texttt{nlp\_performer\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_performer\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_performer\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_perplexity\_value}}{nlp\_perplexity\_value}}\label{nlp_perplexity_value}

\texttt{nlp\_perplexity\_value} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_perplexity\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_perplexity\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_phone\_count}}{nlp\_phone\_count}}\label{nlp_phone_count}

\texttt{nlp\_phone\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_phone\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_phone\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_plsa\_step}}{nlp\_plsa\_step}}\label{nlp_plsa_step}

\texttt{nlp\_plsa\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_plsa\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_plsa\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_pmi\_score}}{nlp\_pmi\_score}}\label{nlp_pmi_score}

\texttt{nlp\_pmi\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_pmi\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_pmi\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_pointwise\_attn\_score}}{nlp\_pointwise\_attn\_score}}\label{nlp_pointwise_attn_score}

\texttt{nlp\_pointwise\_attn\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_pointwise\_attn\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_pointwise\_attn\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_position\_encoding\_cos}}{nlp\_position\_encoding\_cos}}\label{nlp_position_encoding_cos}

\texttt{nlp\_position\_encoding\_cos} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_position\_encoding\_cos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_position\_encoding\_cos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_position\_encoding\_sin}}{nlp\_position\_encoding\_sin}}\label{nlp_position_encoding_sin}

\texttt{nlp\_position\_encoding\_sin} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_position\_encoding\_sin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_position\_encoding\_sin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_punct\_ratio}}{nlp\_punct\_ratio}}\label{nlp_punct_ratio}

\texttt{nlp\_punct\_ratio} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_punct\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_punct\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_query\_likelihood\_step}}{nlp\_query\_likelihood\_step}}\label{nlp_query_likelihood_step}

\texttt{nlp\_query\_likelihood\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_query\_likelihood\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_query\_likelihood\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_reformer\_step}}{nlp\_reformer\_step}}\label{nlp_reformer_step}

\texttt{nlp\_reformer\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_reformer\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_reformer\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_relative\_position\_bias}}{nlp\_relative\_position\_bias}}\label{nlp_relative_position_bias}

\texttt{nlp\_relative\_position\_bias} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_relative\_position\_bias $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_relative\_position\_bias |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_rope\_apply\_step}}{nlp\_rope\_apply\_step}}\label{nlp_rope_apply_step}

\texttt{nlp\_rope\_apply\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_rope\_apply\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_rope\_apply\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_rope\_rotary\_angle}}{nlp\_rope\_rotary\_angle}}\label{nlp_rope_rotary_angle}

\texttt{nlp\_rope\_rotary\_angle} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_rope\_rotary\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_rope\_rotary\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_rouge\_score\_n}}{nlp\_rouge\_score\_n}}\label{nlp_rouge_score_n}

\texttt{nlp\_rouge\_score\_n} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_rouge\_score\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_rouge\_score\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_routing\_attn\_step}}{nlp\_routing\_attn\_step}}\label{nlp_routing_attn_step}

\texttt{nlp\_routing\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_routing\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_routing\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_self\_attn\_compute\_step}}{nlp\_self\_attn\_compute\_step}}\label{nlp_self_attn_compute_step}

\texttt{nlp\_self\_attn\_compute\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_self\_attn\_compute\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_self\_attn\_compute\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_sentencepiece\_score}}{nlp\_sentencepiece\_score}}\label{nlp_sentencepiece_score}

\texttt{nlp\_sentencepiece\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_sentencepiece\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_sentencepiece\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_sif\_weight\_step}}{nlp\_sif\_weight\_step}}\label{nlp_sif_weight_step}

\texttt{nlp\_sif\_weight\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_sif\_weight\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_sif\_weight\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_simpson\_coefficient}}{nlp\_simpson\_coefficient}}\label{nlp_simpson_coefficient}

\texttt{nlp\_simpson\_coefficient} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_simpson\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_simpson\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_skip\_gram\_count}}{nlp\_skip\_gram\_count}}\label{nlp_skip_gram_count}

\texttt{nlp\_skip\_gram\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_skip\_gram\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_skip\_gram\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_sliding\_window\_step}}{nlp\_sliding\_window\_step}}\label{nlp_sliding_window_step}

\texttt{nlp\_sliding\_window\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_sliding\_window\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_sliding\_window\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_sparse\_attn\_score}}{nlp\_sparse\_attn\_score}}\label{nlp_sparse_attn_score}

\texttt{nlp\_sparse\_attn\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_sparse\_attn\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_sparse\_attn\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_strided\_attn\_step}}{nlp\_strided\_attn\_step}}\label{nlp_strided_attn_step}

\texttt{nlp\_strided\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_strided\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_strided\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_subword\_regularization}}{nlp\_subword\_regularization}}\label{nlp_subword_regularization}

\texttt{nlp\_subword\_regularization} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_subword\_regularization $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_subword\_regularization |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_sum\_pool\_step}}{nlp\_sum\_pool\_step}}\label{nlp_sum_pool_step}

\texttt{nlp\_sum\_pool\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_sum\_pool\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_sum\_pool\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_t\_score\_collocation}}{nlp\_t\_score\_collocation}}\label{nlp_t_score_collocation}

\texttt{nlp\_t\_score\_collocation} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_t\_score\_collocation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_t\_score\_collocation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_ter\_score}}{nlp\_ter\_score}}\label{nlp_ter_score}

\texttt{nlp\_ter\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_ter\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_ter\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_tf\_idf\_step}}{nlp\_tf\_idf\_step}}\label{nlp_tf_idf_step}

\texttt{nlp\_tf\_idf\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_tf\_idf\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_tf\_idf\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_token\_drop\_rate}}{nlp\_token\_drop\_rate}}\label{nlp_token_drop_rate}

\texttt{nlp\_token\_drop\_rate} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_token\_drop\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_token\_drop\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_token\_overlap\_two}}{nlp\_token\_overlap\_two}}\label{nlp_token_overlap_two}

\texttt{nlp\_token\_overlap\_two} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_token\_overlap\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_token\_overlap\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_unigram\_lm\_score}}{nlp\_unigram\_lm\_score}}\label{nlp_unigram_lm_score}

\texttt{nlp\_unigram\_lm\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_unigram\_lm\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_unigram\_lm\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_unigram\_subword\_loss}}{nlp\_unigram\_subword\_loss}}\label{nlp_unigram_subword_loss}

\texttt{nlp\_unigram\_subword\_loss} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_unigram\_subword\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_unigram\_subword\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_uppercase\_ratio}}{nlp\_uppercase\_ratio}}\label{nlp_uppercase_ratio}

\texttt{nlp\_uppercase\_ratio} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_uppercase\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_uppercase\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_url\_count}}{nlp\_url\_count}}\label{nlp_url_count}

\texttt{nlp\_url\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_url\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_url\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_wer\_score}}{nlp\_wer\_score}}\label{nlp_wer_score}

\texttt{nlp\_wer\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_wer\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_wer\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_window\_attn\_step}}{nlp\_window\_attn\_step}}\label{nlp_window_attn_step}

\texttt{nlp\_window\_attn\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_window\_attn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_window\_attn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_witten\_bell\_step}}{nlp\_witten\_bell\_step}}\label{nlp_witten_bell_step}

\texttt{nlp\_witten\_bell\_step} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_witten\_bell\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_witten\_bell\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_word2vec\_cbow\_loss}}{nlp\_word2vec\_cbow\_loss}}\label{nlp_word2vec_cbow_loss}

\texttt{nlp\_word2vec\_cbow\_loss} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_word2vec\_cbow\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_word2vec\_cbow\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_word2vec\_skipgram\_loss}}{nlp\_word2vec\_skipgram\_loss}}\label{nlp_word2vec_skipgram_loss}

\texttt{nlp\_word2vec\_skipgram\_loss} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_word2vec\_skipgram\_loss $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_word2vec\_skipgram\_loss |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_word\_freq\_value}}{nlp\_word\_freq\_value}}\label{nlp_word_freq_value}

\texttt{nlp\_word\_freq\_value} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_word\_freq\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_word\_freq\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_word\_mover\_dist}}{nlp\_word\_mover\_dist}}\label{nlp_word_mover_dist}

\texttt{nlp\_word\_mover\_dist} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_word\_mover\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_word\_mover\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_word\_ngram\_count}}{nlp\_word\_ngram\_count}}\label{nlp_word_ngram_count}

\texttt{nlp\_word\_ngram\_count} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_word\_ngram\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_word\_ngram\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nlp\_wordpiece\_score}}{nlp\_wordpiece\_score}}\label{nlp_wordpiece_score}

\texttt{nlp\_wordpiece\_score} --- batch 46 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nlp\_wordpiece\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nlp\_wordpiece\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nm\_from\_fst}}{nm\_from\_fst}}\label{nm_from_fst}

\texttt{nm\_from\_fst} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nm\_from\_fst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nm\_from\_fst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nmass}}{nmass}}\label{nmass}

\texttt{nmass} --- physics constants builtin. Alias for
\texttt{neutron\_mass}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nmass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nmass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nne}}{nne}}\label{nne}

\texttt{nne} --- algebraic match builtin. Alias for \texttt{nnext}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nne $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nne |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nnext}}{nnext}}\label{nnext}

\texttt{nnext} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nnext $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nnext |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nohtml}}{nohtml}}\label{nohtml}

\texttt{nohtml} --- string processing (uncategorized batch) builtin.
Alias for \texttt{strip\_html}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nohtml $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nohtml |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{noise\_model\_depolarize}}{noise\_model\_depolarize}}\label{noise_model_depolarize}

\texttt{noise\_model\_depolarize} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = noise\_model\_depolarize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map noise\_model\_depolarize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nominal}}{nominal}}\label{nominal}

\texttt{nominal} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nominal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nominal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{none\_match}}{none\_match}}\label{none_match}

\texttt{none\_match} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = none\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map none\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nonem}}{nonem}}\label{nonem}

\texttt{nonem} --- python/ruby stdlib builtin. Alias for
\texttt{none\_match}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nonem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nonem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nonempty\_count}}{nonempty\_count}}\label{nonempty_count}

\texttt{nonempty\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nonempty\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nonempty\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nonlinear\_dual\_step}}{nonlinear\_dual\_step}}\label{nonlinear_dual_step}

\texttt{nonlinear\_dual\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nonlinear\_dual\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nonlinear\_dual\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nonzero}}{nonzero}}\label{nonzero}

\texttt{nonzero} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nonzero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nonzero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nonzero\_count}}{nonzero\_count}}\label{nonzero_count}

\texttt{nonzero\_count} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nonzero\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nonzero\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{noop\_val}}{noop\_val}}\label{noop_val}

\texttt{noop\_val} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = noop\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map noop\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nop}}{nop}}\label{nop}

\texttt{nop} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normal\_cdf}}{normal\_cdf}}\label{normal_cdf}

\texttt{normal\_cdf(\$x,\ \$mu,\ \$sigma)} (alias \texttt{normcdf}) ---
cumulative distribution function. Returns probability that a value is ≤
x.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p normcdf(0)              \# 0.5 (half below mean)}
\NormalTok{p normcdf(1.96)           \# \textasciitilde{}0.975 (95\% confidence bound)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normal\_pdf}}{normal\_pdf}}\label{normal_pdf}

\texttt{normal\_pdf(\$x,\ \$mu,\ \$sigma)} (alias \texttt{normpdf}) ---
normal/Gaussian distribution probability density function. Default: μ=0,
σ=1 (standard normal).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p normpdf(0)              \# \textasciitilde{}0.399 (peak of standard normal)}
\NormalTok{p normpdf(0, 100, 15)     \# PDF at IQ=100, mean=100, stddev=15}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normality\_chem}}{normality\_chem}}\label{normality_chem}

\texttt{normality\_chem} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normality\_chem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normality\_chem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_array}}{normalize\_array}}\label{normalize_array}

\texttt{normalize\_array} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normalize\_array $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normalize\_array |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_list}}{normalize\_list}}\label{normalize_list}

\texttt{normalize\_list} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normalize\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normalize\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_range}}{normalize\_range}}\label{normalize_range}

\texttt{normalize\_range} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normalize\_range $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normalize\_range |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_signal}}{normalize\_signal}}\label{normalize_signal}

\texttt{normalize\_signal(\textbackslash{}@signal)} (alias
\texttt{normsig}) --- scales signal to range {[}-1, 1{]} based on its
peak absolute value. Useful for audio processing.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $norm = normsig(\textbackslash{}@audio)}
\NormalTok{p max(map \{ abs \} @$norm)   \# 1}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_spaces}}{normalize\_spaces}}\label{normalize_spaces}

\texttt{normalize\_spaces} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normalize\_spaces $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normalize\_spaces |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_vec}}{normalize\_vec}}\label{normalize_vec}

\texttt{normalize\_vec} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normalize\_vec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normalize\_vec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normalize\_whitespace}}{normalize\_whitespace}}\label{normalize_whitespace}

\texttt{normalize\_whitespace} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normalize\_whitespace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normalize\_whitespace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{normarr}}{normarr}}\label{normarr}

\texttt{normarr} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{normalize\_array}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = normarr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map normarr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{not\_any}}{not\_any}}\label{not_any}

\texttt{not\_any} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = not\_any $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map not\_any |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{not\_each}}{not\_each}}\label{not_each}

\texttt{not\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = not\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map not\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{not\_elem}}{not\_elem}}\label{not_elem}

\texttt{not\_elem} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = not\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map not\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{not\_every}}{not\_every}}\label{not_every}

\texttt{not\_every} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = not\_every $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map not\_every |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{notall}}{notall}}\label{notall}

\texttt{notall} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = notall $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map notall |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{notch\_filter}}{notch\_filter}}\label{notch_filter}

\texttt{notch\_filter} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = notch\_filter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map notch\_filter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{note\_name\_from\_midi}}{note\_name\_from\_midi}}\label{note_name_from_midi}

\texttt{note\_name\_from\_midi} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = note\_name\_from\_midi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map note\_name\_from\_midi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{note\_name\_to\_midi}}{note\_name\_to\_midi}}\label{note_name_to_midi}

\texttt{note\_name\_to\_midi} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = note\_name\_to\_midi $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{now}}{now}}\label{now}

\texttt{now} --- Unix epoch seconds. Returns the current time as the
number of seconds since \texttt{1970-01-01T00:00:00Z}, like
Perl\textquotesingle s \texttt{time()}. Pass a timezone string (e.g.
\texttt{now("UTC")} or \texttt{now("America/New\_York")}) to get an
ISO-8601 datetime string in that zone instead --- that path forwards to
\texttt{datetime\_now\_tz}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p now              \# 1778262882}
\NormalTok{p now("UTC")       \# 2026{-}05{-}08T17:54:42.577935Z}
\NormalTok{my $start = now}
\NormalTok{\# ... do work ...}
\NormalTok{printf "elapsed: \%d s\textbackslash{}n", now {-} $start}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{now\_ms}}{now\_ms}}\label{now_ms}

\texttt{now\_ms} --- now / timestamp builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = now\_ms $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map now\_ms |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{now\_ns}}{now\_ns}}\label{now_ns}

\texttt{now\_ns} --- now / timestamp builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = now\_ns $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map now\_ns |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{now\_us}}{now\_us}}\label{now_us}

\texttt{now\_us} --- now / timestamp builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = now\_us $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map now\_us |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nper}}{nper}}\label{nper}

\texttt{nper(\$rate,\ \$pmt,\ \$pv)} (alias \texttt{num\_periods}) ---
computes the number of periods needed to pay off a loan given rate,
payment, and principal.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p nper(0.05/12, 500, 50000)   \# \textasciitilde{}127 months}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{npv}}{npv}}\label{npv}

\texttt{npv} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = npv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map npv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nrmrng}}{nrmrng}}\label{nrmrng}

\texttt{nrmrng} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{normalize\_range}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nrmrng $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nrmrng |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nrmsp}}{nrmsp}}\label{nrmsp}

\texttt{nrmsp} --- extended stdlib builtin. Alias for
\texttt{normalize\_spaces}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nrmsp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nrmsp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nrmv}}{nrmv}}\label{nrmv}

\texttt{nrmv} --- extended stdlib builtin. Alias for
\texttt{normalize\_vec}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nrmv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nrmv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nroot}}{nroot}}\label{nroot}

\texttt{nroot} --- extended stdlib builtin. Alias for
\texttt{nth\_root\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nroot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nroot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nrow}}{nrow}}\label{nrow}

\texttt{nrow} --- number of rows in a matrix.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p nrow([[1,2],[3,4],[5,6]])  \# 3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ns\_to\_ms}}{ns\_to\_ms}}\label{ns_to_ms}

\texttt{ns\_to\_ms} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ns\_to\_ms $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ns\_to\_us}}{ns\_to\_us}}\label{ns_to_us}

\texttt{ns\_to\_us} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ns\_to\_us $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ntelm}}{ntelm}}\label{ntelm}

\texttt{ntelm} --- haskell list functions builtin. Alias for
\texttt{not\_elem}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ntelm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ntelm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth\_largest}}{nth\_largest}}\label{nth_largest}

\texttt{nth\_largest} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nth\_largest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nth\_largest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth\_prime}}{nth\_prime}}\label{nth_prime}

\texttt{nth\_prime} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nth\_prime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nth\_prime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth\_root}}{nth\_root}}\label{nth_root}

\texttt{nth\_root} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nth\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nth\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth\_root\_of}}{nth\_root\_of}}\label{nth_root_of}

\texttt{nth\_root\_of} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nth\_root\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nth\_root\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth\_smallest}}{nth\_smallest}}\label{nth_smallest}

\texttt{nth\_smallest} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nth\_smallest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nth\_smallest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nth\_word}}{nth\_word}}\label{nth_word}

\texttt{nth\_word} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nth\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nth\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nthp}}{nthp}}\label{nthp}

\texttt{nthp} --- number theory / primes builtin. Alias for
\texttt{nth\_prime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nthp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nthp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nub}}{nub}}\label{nub}

\texttt{nub} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nub\_by}}{nub\_by}}\label{nub_by}

\texttt{nub\_by} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nub\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nub\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nub\_count}}{nub\_count}}\label{nub_count}

\texttt{nub\_count} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nub\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nub\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nub\_list}}{nub\_list}}\label{nub_list}

\texttt{nub\_list} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nub\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nub\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nubb}}{nubb}}\label{nubb}

\texttt{nubb} --- additional missing stdlib functions builtin. Alias for
\texttt{nub\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nubb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nubb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nuclear\_magneton}}{nuclear\_magneton}}\label{nuclear_magneton}

\texttt{nuclear\_magneton} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nuclear\_magneton $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nuclear\_magneton |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nucleation\_rate\_constant}}{nucleation\_rate\_constant}}\label{nucleation_rate_constant}

\texttt{nucleation\_rate\_constant} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nucleation\_rate\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nucleation\_rate\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nucleolus\_lp\_step}}{nucleolus\_lp\_step}}\label{nucleolus_lp_step}

\texttt{nucleolus\_lp\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nucleolus\_lp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nucleolus\_lp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{num\_cpus}}{num\_cpus}}\label{num_cpus}

\texttt{num\_cpus} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = num\_cpus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map num\_cpus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{num\_divisors}}{num\_divisors}}\label{num_divisors}

\texttt{num\_divisors} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = num\_divisors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map num\_divisors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{num\_edges}}{num\_edges}}\label{num_edges}

\texttt{num\_edges} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = num\_edges $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map num\_edges |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{num\_unrooted\_trees}}{num\_unrooted\_trees}}\label{num_unrooted_trees}

\texttt{num\_unrooted\_trees} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = num\_unrooted\_trees $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map num\_unrooted\_trees |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{number\_needed\_to\_treat}}{number\_needed\_to\_treat}}\label{number_needed_to_treat}

\texttt{number\_needed\_to\_treat} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = number\_needed\_to\_treat $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{number\_to\_english}}{number\_to\_english}}\label{number_to_english}

\texttt{number\_to\_english} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = number\_to\_english $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{numeric\_count}}{numeric\_count}}\label{numeric_count}

\texttt{numeric\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = numeric\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map numeric\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{numerical\_jacobian\_col}}{numerical\_jacobian\_col}}\label{numerical_jacobian_col}

\texttt{numerical\_jacobian\_col} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = numerical\_jacobian\_col $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map numerical\_jacobian\_col |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nusselt\_dittus\_boelter}}{nusselt\_dittus\_boelter}}\label{nusselt_dittus_boelter}

\texttt{nusselt\_dittus\_boelter} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nusselt\_dittus\_boelter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nusselt\_dittus\_boelter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nusselt\_full\_number}}{nusselt\_full\_number}}\label{nusselt_full_number}

\texttt{nusselt\_full\_number} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nusselt\_full\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nusselt\_full\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nutation\_iau2000a}}{nutation\_iau2000a}}\label{nutation_iau2000a}

\texttt{nutation\_iau2000a} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nutation\_iau2000a $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nutation\_iau2000a |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nuttall\_w}}{nuttall\_w}}\label{nuttall_w}

\texttt{nuttall\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nuttall\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nuttall\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nxtp}}{nxtp}}\label{nxtp}

\texttt{nxtp} --- number theory / primes builtin. Alias for
\texttt{next\_prime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nxtp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nxtp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nxtperm}}{nxtperm}}\label{nxtperm}

\texttt{nxtperm} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{next\_permutation}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nxtperm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nxtperm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nyquist\_encirclement}}{nyquist\_encirclement}}\label{nyquist_encirclement}

\texttt{nyquist\_encirclement} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nyquist\_encirclement $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nyquist\_encirclement |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nyquist\_phase}}{nyquist\_phase}}\label{nyquist_phase}

\texttt{nyquist\_phase} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nyquist\_phase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nyquist\_phase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{nysiis\_phonetic}}{nysiis\_phonetic}}\label{nysiis_phonetic}

\texttt{nysiis\_phonetic} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = nysiis\_phonetic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map nysiis\_phonetic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oaconvolve\_step}}{oaconvolve\_step}}\label{oaconvolve_step}

\texttt{oaconvolve\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oaconvolve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map oaconvolve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oat\_hash}}{oat\_hash}}\label{oat_hash}

\texttt{oat\_hash} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oat\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map oat\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{object\_encoding}}{object\_encoding}}\label{object_encoding}

\texttt{object\_encoding} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = object\_encoding $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map object\_encoding |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{object\_entries}}{object\_entries}}\label{object_entries}

\texttt{object\_entries} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = object\_entries $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map object\_entries |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{object\_from\_entries}}{object\_from\_entries}}\label{object_from_entries}

\texttt{object\_from\_entries} --- javascript array/object methods
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = object\_from\_entries $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map object\_from\_entries |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{object\_keys}}{object\_keys}}\label{object_keys}

\texttt{object\_keys} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = object\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map object\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{object\_values}}{object\_values}}\label{object_values}

\texttt{object\_values} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = object\_values $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map object\_values |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oct\_of}}{oct\_of}}\label{oct_of}

\texttt{oct\_of} --- base conversion builtin. Alias for
\texttt{to\_oct}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oct\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map oct\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{octahedral\_number}}{octahedral\_number}}\label{octahedral_number}

\texttt{octahedral\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = octahedral\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map octahedral\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ocv\_lithium\_ion\_step}}{ocv\_lithium\_ion\_step}}\label{ocv_lithium_ion_step}

\texttt{ocv\_lithium\_ion\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ocv\_lithium\_ion\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ocv\_lithium\_ion\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{odd}}{odd}}\label{odd}

\texttt{odd} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = odd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map odd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{odddyield}}{odddyield}}\label{odddyield}

\texttt{odddyield} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = odddyield $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map odddyield |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{odds\_ratio\_2x2}}{odds\_ratio\_2x2}}\label{odds_ratio_2x2}

\texttt{odds\_ratio\_2x2} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = odds\_ratio\_2x2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map odds\_ratio\_2x2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ode45\_step}}{ode45\_step}}\label{ode45_step}

\texttt{ode45\_step} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ode45\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ode45\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ode\_lsoda}}{ode\_lsoda}}\label{ode_lsoda}

\texttt{ode\_lsoda} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ode\_lsoda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ode\_lsoda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oents}}{oents}}\label{oents}

\texttt{oents} --- javascript array/object methods builtin. Alias for
\texttt{object\_entries}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oents $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map oents |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ofents}}{ofents}}\label{ofents}

\texttt{ofents} --- javascript array/object methods builtin. Alias for
\texttt{object\_from\_entries}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ofents $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ofents |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{off}}{off}}\label{off}

\texttt{off} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = off $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map off |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{offset}}{offset}}\label{offset}

\texttt{offset} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = offset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map offset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{offset\_each}}{offset\_each}}\label{offset_each}

\texttt{offset\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = offset\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map offset\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ohm\_voltage}}{ohm\_voltage}}\label{ohm_voltage}

\texttt{ohm\_voltage} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ohm\_voltage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ohm\_voltage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ohms\_law\_i}}{ohms\_law\_i}}\label{ohms_law_i}

\texttt{ohms\_law\_i} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ohms\_law\_i $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ohms\_law\_i |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ohms\_law\_r}}{ohms\_law\_r}}\label{ohms_law_r}

\texttt{ohms\_law\_r} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ohms\_law\_r $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ohms\_law\_r |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ohms\_law\_v}}{ohms\_law\_v}}\label{ohms_law_v}

\texttt{ohms\_law\_v} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ohms\_law\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ohms\_law\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{okeys}}{okeys}}\label{okeys}

\texttt{okeys} --- javascript array/object methods builtin. Alias for
\texttt{object\_keys}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = okeys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map okeys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oklab\_to\_rgb}}{oklab\_to\_rgb}}\label{oklab_to_rgb}

\texttt{oklab\_to\_rgb} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oklab\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ols\_adjusted\_r2}}{ols\_adjusted\_r2}}\label{ols_adjusted_r2}

\texttt{ols\_adjusted\_r2} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ols\_adjusted\_r2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ols\_adjusted\_r2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ols\_estimator}}{ols\_estimator}}\label{ols_estimator}

\texttt{ols\_estimator} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ols\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ols\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ols\_r\_squared}}{ols\_r\_squared}}\label{ols_r_squared}

\texttt{ols\_r\_squared} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ols\_r\_squared $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ols\_r\_squared |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ols\_residual\_variance}}{ols\_residual\_variance}}\label{ols_residual_variance}

\texttt{ols\_residual\_variance} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ols\_residual\_variance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ols\_residual\_variance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{omega\_equation\_step}}{omega\_equation\_step}}\label{omega_equation_step}

\texttt{omega\_equation\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = omega\_equation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map omega\_equation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{omega\_m\_at\_z}}{omega\_m\_at\_z}}\label{omega_m_at_z}

\texttt{omega\_m\_at\_z} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = omega\_m\_at\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map omega\_m\_at\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{omega\_ratio}}{omega\_ratio}}\label{omega_ratio}

\texttt{omega\_ratio} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = omega\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map omega\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{omit}}{omit}}\label{omit}

\texttt{omit} --- hash ops (batch 2) builtin. Alias for
\texttt{omit\_keys}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = omit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map omit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{omit\_keys}}{omit\_keys}}\label{omit_keys}

\texttt{omit\_keys} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = omit\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map omit\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{omori\_aftershock}}{omori\_aftershock}}\label{omori_aftershock}

\texttt{omori\_aftershock} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = omori\_aftershock $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map omori\_aftershock |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{one}}{one}}\label{one}

\texttt{one} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = one $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map one |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{one\_hot}}{one\_hot}}\label{one_hot}

\texttt{one\_hot} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = one\_hot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map one\_hot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ones}}{ones}}\label{ones}

\texttt{ones} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ones $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ones |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ones\_mat}}{ones\_mat}}\label{ones_mat}

\texttt{ones\_mat} --- matrix / linear algebra builtin. Alias for
\texttt{ones\_matrix}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ones\_mat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ones\_mat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ones\_matrix}}{ones\_matrix}}\label{ones_matrix}

\texttt{ones\_matrix} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ones\_matrix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ones\_matrix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{only\_alnum}}{only\_alnum}}\label{only_alnum}

\texttt{only\_alnum} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = only\_alnum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map only\_alnum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{only\_alpha}}{only\_alpha}}\label{only_alpha}

\texttt{only\_alpha} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = only\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map only\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{only\_ascii}}{only\_ascii}}\label{only_ascii}

\texttt{only\_ascii} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = only\_ascii $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map only\_ascii |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{only\_digits}}{only\_digits}}\label{only_digits}

\texttt{only\_digits} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = only\_digits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map only\_digits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{onsager\_relation\_two\_species}}{onsager\_relation\_two\_species}}\label{onsager_relation_two_species}

\texttt{onsager\_relation\_two\_species} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = onsager\_relation\_two\_species $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map onsager\_relation\_two\_species |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{open\_pipe\_harmonic}}{open\_pipe\_harmonic}}\label{open_pipe_harmonic}

\texttt{open\_pipe\_harmonic} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = open\_pipe\_harmonic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map open\_pipe\_harmonic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{operad\_count\_two}}{operad\_count\_two}}\label{operad_count_two}

\texttt{operad\_count\_two} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = operad\_count\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map operad\_count\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oppenheimer\_volkoff\_step}}{oppenheimer\_volkoff\_step}}\label{oppenheimer_volkoff_step}

\texttt{oppenheimer\_volkoff\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oppenheimer\_volkoff\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map oppenheimer\_volkoff\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ops\_plus}}{ops\_plus}}\label{ops_plus}

\texttt{ops\_plus} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ops\_plus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ops\_plus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{optical\_flow\_farneback}}{optical\_flow\_farneback}}\label{optical_flow_farneback}

\texttt{optical\_flow\_farneback} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = optical\_flow\_farneback $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map optical\_flow\_farneback |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{optical\_flow\_lk}}{optical\_flow\_lk}}\label{optical_flow_lk}

\texttt{optical\_flow\_lk} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = optical\_flow\_lk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map optical\_flow\_lk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{optical\_flow\_lk\_step}}{optical\_flow\_lk\_step}}\label{optical_flow_lk_step}

\texttt{optical\_flow\_lk\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = optical\_flow\_lk\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map optical\_flow\_lk\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{optical\_scalars\_step}}{optical\_scalars\_step}}\label{optical_scalars_step}

\texttt{optical\_scalars\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = optical\_scalars\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map optical\_scalars\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{or}}{or}}\label{or}

\texttt{or} --- control flow builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = or $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map or |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{or\_list}}{or\_list}}\label{or_list}

\texttt{or\_list} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = or\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map or\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{or\_opt\_delta}}{or\_opt\_delta}}\label{or_opt_delta}

\texttt{or\_opt\_delta} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = or\_opt\_delta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map or\_opt\_delta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orb\_keypoints}}{orb\_keypoints}}\label{orb_keypoints}

\texttt{orb\_keypoints} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orb\_keypoints $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orb\_keypoints |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orbit\_eccentric\_anomaly}}{orbit\_eccentric\_anomaly}}\label{orbit_eccentric_anomaly}

\texttt{orbit\_eccentric\_anomaly} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orbit\_eccentric\_anomaly $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orbit\_eccentric\_anomaly |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orbit\_kepler3}}{orbit\_kepler3}}\label{orbit_kepler3}

\texttt{orbit\_kepler3} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orbit\_kepler3 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orbit\_kepler3 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orbital\_eccentricity}}{orbital\_eccentricity}}\label{orbital_eccentricity}

\texttt{orbital\_eccentricity} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orbital\_eccentricity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orbital\_eccentricity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orbital\_period}}{orbital\_period}}\label{orbital_period}

\texttt{orbital\_period(\$mass,\ \$radius)} (alias \texttt{orbper}) ---
period for circular orbit: T = 2π√(r³/GM). Returns seconds.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $t = orbper       \# \textasciitilde{}5560 s (ISS orbital period)}
\NormalTok{p $t / 60            \# \textasciitilde{}93 minutes}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orbital\_period\_au}}{orbital\_period\_au}}\label{orbital_period_au}

\texttt{orbital\_period\_au} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orbital\_period\_au $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orbital\_period\_au |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orbital\_velocity}}{orbital\_velocity}}\label{orbital_velocity}

\texttt{orbital\_velocity(\$mass,\ \$radius)} (alias \texttt{orbvel})
--- velocity for circular orbit: v = √(GM/r). Defaults to LEO around
Earth.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p orbvel    \# \textasciitilde{}7672 m/s (ISS orbital speed)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ordered\_probit\_threshold}}{ordered\_probit\_threshold}}\label{ordered_probit_threshold}

\texttt{ordered\_probit\_threshold} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ordered\_probit\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ordered\_probit\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ordered\_set}}{ordered\_set}}\label{ordered_set}

\texttt{ordered\_set} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ordered\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ordered\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ordinal\_date}}{ordinal\_date}}\label{ordinal_date}

\texttt{ordinal\_date} --- batch 10 builtin. Alias for
\texttt{iso\_ordinal\_date}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ordinal\_date $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ordinal\_date |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ordinalize}}{ordinalize}}\label{ordinalize}

\texttt{ordinalize} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ordinalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ordinalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ordn}}{ordn}}\label{ordn}

\texttt{ordn} --- extended stdlib builtin. Alias for
\texttt{ordinalize}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ordn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ordn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orifice\_velocity}}{orifice\_velocity}}\label{orifice_velocity}

\texttt{orifice\_velocity} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orifice\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orifice\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orl}}{orl}}\label{orl}

\texttt{orl} --- additional missing stdlib functions builtin. Alias for
\texttt{or\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{orthogonalize\_vectors}}{orthogonalize\_vectors}}\label{orthogonalize_vectors}

\texttt{orthogonalize\_vectors} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = orthogonalize\_vectors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map orthogonalize\_vectors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_acpi\_state\_transition}}{os\_acpi\_state\_transition}}\label{os_acpi_state_transition}

\texttt{os\_acpi\_state\_transition} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_acpi\_state\_transition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_acpi\_state\_transition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_amd\_pstate\_target}}{os\_amd\_pstate\_target}}\label{os_amd_pstate_target}

\texttt{os\_amd\_pstate\_target} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_amd\_pstate\_target $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_amd\_pstate\_target |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_anticipation\_window}}{os\_anticipation\_window}}\label{os_anticipation_window}

\texttt{os\_anticipation\_window} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_anticipation\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_anticipation\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_apic\_irq\_priority}}{os\_apic\_irq\_priority}}\label{os_apic_irq_priority}

\texttt{os\_apic\_irq\_priority} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_apic\_irq\_priority $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_apic\_irq\_priority |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_apparmor\_profile\_active}}{os\_apparmor\_profile\_active}}\label{os_apparmor_profile_active}

\texttt{os\_apparmor\_profile\_active} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_apparmor\_profile\_active $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_apparmor\_profile\_active |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_arch}}{os\_arch}}\label{os_arch}

\texttt{os\_arch} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_arch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_arch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_audit\_event\_priority}}{os\_audit\_event\_priority}}\label{os_audit_event_priority}

\texttt{os\_audit\_event\_priority} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_audit\_event\_priority $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_audit\_event\_priority |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_battery\_capacity\_pct}}{os\_battery\_capacity\_pct}}\label{os_battery_capacity_pct}

\texttt{os\_battery\_capacity\_pct} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_battery\_capacity\_pct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_battery\_capacity\_pct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_buddy\_order\_pick}}{os\_buddy\_order\_pick}}\label{os_buddy_order_pick}

\texttt{os\_buddy\_order\_pick} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_buddy\_order\_pick $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_buddy\_order\_pick |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_buffer\_cache\_pages}}{os\_buffer\_cache\_pages}}\label{os_buffer_cache_pages}

\texttt{os\_buffer\_cache\_pages} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_buffer\_cache\_pages $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_buffer\_cache\_pages |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_c\_state\_residency}}{os\_c\_state\_residency}}\label{os_c_state_residency}

\texttt{os\_c\_state\_residency} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_c\_state\_residency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_c\_state\_residency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_capability\_check}}{os\_capability\_check}}\label{os_capability_check}

\texttt{os\_capability\_check} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_capability\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_capability\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_cfs\_load\_balance\_step}}{os\_cfs\_load\_balance\_step}}\label{os_cfs_load_balance_step}

\texttt{os\_cfs\_load\_balance\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_cfs\_load\_balance\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_cfs\_load\_balance\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_cgroup\_v1\_count}}{os\_cgroup\_v1\_count}}\label{os_cgroup_v1_count}

\texttt{os\_cgroup\_v1\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_cgroup\_v1\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_cgroup\_v1\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_cgroup\_v2\_count}}{os\_cgroup\_v2\_count}}\label{os_cgroup_v2_count}

\texttt{os\_cgroup\_v2\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_cgroup\_v2\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_cgroup\_v2\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_compact\_memory\_step}}{os\_compact\_memory\_step}}\label{os_compact_memory_step}

\texttt{os\_compact\_memory\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_compact\_memory\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_compact\_memory\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_completely\_fair\_vruntime}}{os\_completely\_fair\_vruntime}}\label{os_completely_fair_vruntime}

\texttt{os\_completely\_fair\_vruntime} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_completely\_fair\_vruntime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_completely\_fair\_vruntime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_copy\_on\_write\_check}}{os\_copy\_on\_write\_check}}\label{os_copy_on_write_check}

\texttt{os\_copy\_on\_write\_check} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_copy\_on\_write\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_copy\_on\_write\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_cpu\_affinity\_score}}{os\_cpu\_affinity\_score}}\label{os_cpu_affinity_score}

\texttt{os\_cpu\_affinity\_score} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_cpu\_affinity\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_cpu\_affinity\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_cpufreq\_governor\_step}}{os\_cpufreq\_governor\_step}}\label{os_cpufreq_governor_step}

\texttt{os\_cpufreq\_governor\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_cpufreq\_governor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_cpufreq\_governor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_demand\_paging\_step}}{os\_demand\_paging\_step}}\label{os_demand_paging_step}

\texttt{os\_demand\_paging\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_demand\_paging\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_demand\_paging\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_dirty\_page\_threshold}}{os\_dirty\_page\_threshold}}\label{os_dirty_page_threshold}

\texttt{os\_dirty\_page\_threshold} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_dirty\_page\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_dirty\_page\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_disk\_rotational\_lat}}{os\_disk\_rotational\_lat}}\label{os_disk_rotational_lat}

\texttt{os\_disk\_rotational\_lat} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_disk\_rotational\_lat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_disk\_rotational\_lat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_disk\_seek\_time}}{os\_disk\_seek\_time}}\label{os_disk_seek_time}

\texttt{os\_disk\_seek\_time} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_disk\_seek\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_disk\_seek\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_disk\_transfer\_time}}{os\_disk\_transfer\_time}}\label{os_disk_transfer_time}

\texttt{os\_disk\_transfer\_time} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_disk\_transfer\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_disk\_transfer\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_dmesg\_severity\_level}}{os\_dmesg\_severity\_level}}\label{os_dmesg_severity_level}

\texttt{os\_dmesg\_severity\_level} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_dmesg\_severity\_level $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_dmesg\_severity\_level |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_dvfs\_step}}{os\_dvfs\_step}}\label{os_dvfs_step}

\texttt{os\_dvfs\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_dvfs\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_dvfs\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_eas\_energy\_estimate}}{os\_eas\_energy\_estimate}}\label{os_eas_energy_estimate}

\texttt{os\_eas\_energy\_estimate} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_eas\_energy\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_eas\_energy\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_eevdf\_eligible}}{os\_eevdf\_eligible}}\label{os_eevdf_eligible}

\texttt{os\_eevdf\_eligible} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_eevdf\_eligible $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_eevdf\_eligible |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_elevator\_step}}{os\_elevator\_step}}\label{os_elevator_step}

\texttt{os\_elevator\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_elevator\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_elevator\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_epoll\_ctl\_count}}{os\_epoll\_ctl\_count}}\label{os_epoll_ctl_count}

\texttt{os\_epoll\_ctl\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_epoll\_ctl\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_epoll\_ctl\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_family}}{os\_family}}\label{os_family}

\texttt{os\_family} --- OS family string: \texttt{"unix"} or
\texttt{"windows"}. From \texttt{std::env::consts::FAMILY}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p os\_family                              \# unix}
\NormalTok{die "unix only" unless os\_family eq "unix"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_file\_max\_value}}{os\_file\_max\_value}}\label{os_file_max_value}

\texttt{os\_file\_max\_value} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_file\_max\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_file\_max\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_frequency\_scaling\_step}}{os\_frequency\_scaling\_step}}\label{os_frequency_scaling_step}

\texttt{os\_frequency\_scaling\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_frequency\_scaling\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_frequency\_scaling\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_huge\_page\_threshold}}{os\_huge\_page\_threshold}}\label{os_huge_page_threshold}

\texttt{os\_huge\_page\_threshold} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_huge\_page\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_huge\_page\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_idle\_state\_select}}{os\_idle\_state\_select}}\label{os_idle_state_select}

\texttt{os\_idle\_state\_select} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_idle\_state\_select $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_idle\_state\_select |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_inotify\_event\_count}}{os\_inotify\_event\_count}}\label{os_inotify_event_count}

\texttt{os\_inotify\_event\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_inotify\_event\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_inotify\_event\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_inotify\_max\_watches}}{os\_inotify\_max\_watches}}\label{os_inotify_max_watches}

\texttt{os\_inotify\_max\_watches} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_inotify\_max\_watches $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_inotify\_max\_watches |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_intel\_pstate\_target}}{os\_intel\_pstate\_target}}\label{os_intel_pstate_target}

\texttt{os\_intel\_pstate\_target} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_intel\_pstate\_target $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_intel\_pstate\_target |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_scheduler\_bfq\_step}}{os\_io\_scheduler\_bfq\_step}}\label{os_io_scheduler_bfq_step}

\texttt{os\_io\_scheduler\_bfq\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_scheduler\_bfq\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_scheduler\_bfq\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_scheduler\_cfq\_step}}{os\_io\_scheduler\_cfq\_step}}\label{os_io_scheduler_cfq_step}

\texttt{os\_io\_scheduler\_cfq\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_scheduler\_cfq\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_scheduler\_cfq\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_scheduler\_deadline}}{os\_io\_scheduler\_deadline}}\label{os_io_scheduler_deadline}

\texttt{os\_io\_scheduler\_deadline} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_scheduler\_deadline $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_scheduler\_deadline |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_scheduler\_kyber\_step}}{os\_io\_scheduler\_kyber\_step}}\label{os_io_scheduler_kyber_step}

\texttt{os\_io\_scheduler\_kyber\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_scheduler\_kyber\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_scheduler\_kyber\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_scheduler\_mq\_deadline}}{os\_io\_scheduler\_mq\_deadline}}\label{os_io_scheduler_mq_deadline}

\texttt{os\_io\_scheduler\_mq\_deadline} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_scheduler\_mq\_deadline $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_scheduler\_mq\_deadline |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_scheduler\_noop\_step}}{os\_io\_scheduler\_noop\_step}}\label{os_io_scheduler_noop_step}

\texttt{os\_io\_scheduler\_noop\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_scheduler\_noop\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_scheduler\_noop\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_uring\_cqe\_count}}{os\_io\_uring\_cqe\_count}}\label{os_io_uring_cqe_count}

\texttt{os\_io\_uring\_cqe\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_uring\_cqe\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_uring\_cqe\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_io\_uring\_sqe\_count}}{os\_io\_uring\_sqe\_count}}\label{os_io_uring_sqe_count}

\texttt{os\_io\_uring\_sqe\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_io\_uring\_sqe\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_io\_uring\_sqe\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_iommu\_domain\_step}}{os\_iommu\_domain\_step}}\label{os_iommu_domain_step}

\texttt{os\_iommu\_domain\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_iommu\_domain\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_iommu\_domain\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_kasan\_shadow\_offset}}{os\_kasan\_shadow\_offset}}\label{os_kasan_shadow_offset}

\texttt{os\_kasan\_shadow\_offset} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_kasan\_shadow\_offset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_kasan\_shadow\_offset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_kfence\_alloc\_index}}{os\_kfence\_alloc\_index}}\label{os_kfence_alloc_index}

\texttt{os\_kfence\_alloc\_index} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_kfence\_alloc\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_kfence\_alloc\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_kfence\_check}}{os\_kfence\_check}}\label{os_kfence_check}

\texttt{os\_kfence\_check} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_kfence\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_kfence\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_kqueue\_event\_count}}{os\_kqueue\_event\_count}}\label{os_kqueue_event_count}

\texttt{os\_kqueue\_event\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_kqueue\_event\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_kqueue\_event\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_kswapd\_wake\_threshold}}{os\_kswapd\_wake\_threshold}}\label{os_kswapd_wake_threshold}

\texttt{os\_kswapd\_wake\_threshold} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_kswapd\_wake\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_kswapd\_wake\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_kvm\_vmcs\_field\_offset}}{os\_kvm\_vmcs\_field\_offset}}\label{os_kvm_vmcs_field_offset}

\texttt{os\_kvm\_vmcs\_field\_offset} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_kvm\_vmcs\_field\_offset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_kvm\_vmcs\_field\_offset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_load\_average\_decay}}{os\_load\_average\_decay}}\label{os_load_average_decay}

\texttt{os\_load\_average\_decay} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_load\_average\_decay $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_load\_average\_decay |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_load\_iowait\_avg}}{os\_load\_iowait\_avg}}\label{os_load_iowait_avg}

\texttt{os\_load\_iowait\_avg} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_load\_iowait\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_load\_iowait\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_load\_proc\_avg}}{os\_load\_proc\_avg}}\label{os_load_proc_avg}

\texttt{os\_load\_proc\_avg} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_load\_proc\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_load\_proc\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_load\_user\_avg}}{os\_load\_user\_avg}}\label{os_load_user_avg}

\texttt{os\_load\_user\_avg} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_load\_user\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_load\_user\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_lottery\_ticket\_count}}{os\_lottery\_ticket\_count}}\label{os_lottery_ticket_count}

\texttt{os\_lottery\_ticket\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_lottery\_ticket\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_lottery\_ticket\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_mlfq\_demote\_step}}{os\_mlfq\_demote\_step}}\label{os_mlfq_demote_step}

\texttt{os\_mlfq\_demote\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_mlfq\_demote\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_mlfq\_demote\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_mlfq\_promote\_step}}{os\_mlfq\_promote\_step}}\label{os_mlfq_promote_step}

\texttt{os\_mlfq\_promote\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_mlfq\_promote\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_mlfq\_promote\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_msi\_x\_vector\_count}}{os\_msi\_x\_vector\_count}}\label{os_msi_x_vector_count}

\texttt{os\_msi\_x\_vector\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_msi\_x\_vector\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_msi\_x\_vector\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_name}}{os\_name}}\label{os_name}

\texttt{os\_name} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_name $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_name |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_namespace\_isolation}}{os\_namespace\_isolation}}\label{os_namespace_isolation}

\texttt{os\_namespace\_isolation} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_namespace\_isolation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_namespace\_isolation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_numa\_node\_distance}}{os\_numa\_node\_distance}}\label{os_numa_node_distance}

\texttt{os\_numa\_node\_distance} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_numa\_node\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_numa\_node\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_oom\_kill\_score}}{os\_oom\_kill\_score}}\label{os_oom_kill_score}

\texttt{os\_oom\_kill\_score} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_oom\_kill\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_oom\_kill\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_oom\_score\_step}}{os\_oom\_score\_step}}\label{os_oom_score_step}

\texttt{os\_oom\_score\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_oom\_score\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_oom\_score\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_open\_files\_count}}{os\_open\_files\_count}}\label{os_open_files_count}

\texttt{os\_open\_files\_count} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_open\_files\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_open\_files\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_p\_state\_voltage}}{os\_p\_state\_voltage}}\label{os_p_state_voltage}

\texttt{os\_p\_state\_voltage} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_p\_state\_voltage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_p\_state\_voltage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_page\_replacement\_2q}}{os\_page\_replacement\_2q}}\label{os_page_replacement_2q}

\texttt{os\_page\_replacement\_2q} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_page\_replacement\_2q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_page\_replacement\_2q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_page\_replacement\_clock}}{os\_page\_replacement\_clock}}\label{os_page_replacement_clock}

\texttt{os\_page\_replacement\_clock} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_page\_replacement\_clock $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_page\_replacement\_clock |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_page\_replacement\_lru}}{os\_page\_replacement\_lru}}\label{os_page_replacement_lru}

\texttt{os\_page\_replacement\_lru} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_page\_replacement\_lru $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_page\_replacement\_lru |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_pci\_bus\_address}}{os\_pci\_bus\_address}}\label{os_pci_bus_address}

\texttt{os\_pci\_bus\_address} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_pci\_bus\_address $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_pci\_bus\_address |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_per\_cpu\_cache\_size}}{os\_per\_cpu\_cache\_size}}\label{os_per_cpu_cache_size}

\texttt{os\_per\_cpu\_cache\_size} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_per\_cpu\_cache\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_per\_cpu\_cache\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_pid\_max\_value}}{os\_pid\_max\_value}}\label{os_pid_max_value}

\texttt{os\_pid\_max\_value} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_pid\_max\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_pid\_max\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_powertop\_score}}{os\_powertop\_score}}\label{os_powertop_score}

\texttt{os\_powertop\_score} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_powertop\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_powertop\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_pre\_fetch\_window}}{os\_pre\_fetch\_window}}\label{os_pre_fetch_window}

\texttt{os\_pre\_fetch\_window} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_pre\_fetch\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_pre\_fetch\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_pressure\_stall\_step}}{os\_pressure\_stall\_step}}\label{os_pressure_stall_step}

\texttt{os\_pressure\_stall\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_pressure\_stall\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_pressure\_stall\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_priority\_aging\_step}}{os\_priority\_aging\_step}}\label{os_priority_aging_step}

\texttt{os\_priority\_aging\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_priority\_aging\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_priority\_aging\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_psi\_avg10\_step}}{os\_psi\_avg10\_step}}\label{os_psi_avg10_step}

\texttt{os\_psi\_avg10\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_psi\_avg10\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_psi\_avg10\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_psi\_avg300\_step}}{os\_psi\_avg300\_step}}\label{os_psi_avg300_step}

\texttt{os\_psi\_avg300\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_psi\_avg300\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_psi\_avg300\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_psi\_avg60\_step}}{os\_psi\_avg60\_step}}\label{os_psi_avg60_step}

\texttt{os\_psi\_avg60\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_psi\_avg60\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_psi\_avg60\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_round\_robin\_quantum}}{os\_round\_robin\_quantum}}\label{os_round_robin_quantum}

\texttt{os\_round\_robin\_quantum} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_round\_robin\_quantum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_round\_robin\_quantum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_runqueue\_depth}}{os\_runqueue\_depth}}\label{os_runqueue_depth}

\texttt{os\_runqueue\_depth} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_runqueue\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_runqueue\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_seccomp\_filter\_step}}{os\_seccomp\_filter\_step}}\label{os_seccomp_filter_step}

\texttt{os\_seccomp\_filter\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_seccomp\_filter\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_seccomp\_filter\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_selinux\_context\_match}}{os\_selinux\_context\_match}}\label{os_selinux_context_match}

\texttt{os\_selinux\_context\_match} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_selinux\_context\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_selinux\_context\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_slab\_color\_offset}}{os\_slab\_color\_offset}}\label{os_slab_color_offset}

\texttt{os\_slab\_color\_offset} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_slab\_color\_offset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_slab\_color\_offset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_slub\_object\_size\_round}}{os\_slub\_object\_size\_round}}\label{os_slub_object_size_round}

\texttt{os\_slub\_object\_size\_round} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_slub\_object\_size\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_slub\_object\_size\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_smack\_label\_compare}}{os\_smack\_label\_compare}}\label{os_smack_label_compare}

\texttt{os\_smack\_label\_compare} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_smack\_label\_compare $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_smack\_label\_compare |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_smt\_threading\_share}}{os\_smt\_threading\_share}}\label{os_smt_threading_share}

\texttt{os\_smt\_threading\_share} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_smt\_threading\_share $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_smt\_threading\_share |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_socket\_max\_value}}{os\_socket\_max\_value}}\label{os_socket_max_value}

\texttt{os\_socket\_max\_value} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_socket\_max\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_socket\_max\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_stride\_pass\_step}}{os\_stride\_pass\_step}}\label{os_stride_pass_step}

\texttt{os\_stride\_pass\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_stride\_pass\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_stride\_pass\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_swap\_pressure\_score}}{os\_swap\_pressure\_score}}\label{os_swap_pressure_score}

\texttt{os\_swap\_pressure\_score} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_swap\_pressure\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_swap\_pressure\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_swappiness\_factor}}{os\_swappiness\_factor}}\label{os_swappiness_factor}

\texttt{os\_swappiness\_factor} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_swappiness\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_swappiness\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_systemd\_journal\_size}}{os\_systemd\_journal\_size}}\label{os_systemd_journal_size}

\texttt{os\_systemd\_journal\_size} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_systemd\_journal\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_systemd\_journal\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_thermal\_zone\_trip}}{os\_thermal\_zone\_trip}}\label{os_thermal_zone_trip}

\texttt{os\_thermal\_zone\_trip} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_thermal\_zone\_trip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_thermal\_zone\_trip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_thrashing\_threshold}}{os\_thrashing\_threshold}}\label{os_thrashing_threshold}

\texttt{os\_thrashing\_threshold} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_thrashing\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_thrashing\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_thread\_max\_value}}{os\_thread\_max\_value}}\label{os_thread_max_value}

\texttt{os\_thread\_max\_value} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_thread\_max\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_thread\_max\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_thread\_migration\_cost}}{os\_thread\_migration\_cost}}\label{os_thread_migration_cost}

\texttt{os\_thread\_migration\_cost} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_thread\_migration\_cost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_thread\_migration\_cost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_throttle\_temperature}}{os\_throttle\_temperature}}\label{os_throttle_temperature}

\texttt{os\_throttle\_temperature} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_throttle\_temperature $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_throttle\_temperature |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_transparent\_hugepage}}{os\_transparent\_hugepage}}\label{os_transparent_hugepage}

\texttt{os\_transparent\_hugepage} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_transparent\_hugepage $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_transparent\_hugepage |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_version}}{os\_version}}\label{os_version}

\texttt{os\_version} --- OS kernel version/release string from
\texttt{uname}. Returns \texttt{undef} on non-unix.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p os\_version                             \# 25.4.0}
\NormalTok{p "kernel: " . os\_version}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_voltage\_scaling\_step}}{os\_voltage\_scaling\_step}}\label{os_voltage_scaling_step}

\texttt{os\_voltage\_scaling\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_voltage\_scaling\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_voltage\_scaling\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_working\_set\_size}}{os\_working\_set\_size}}\label{os_working_set_size}

\texttt{os\_working\_set\_size} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_working\_set\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_working\_set\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_writeback\_step}}{os\_writeback\_step}}\label{os_writeback_step}

\texttt{os\_writeback\_step} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_writeback\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_writeback\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_zero\_page\_optimization}}{os\_zero\_page\_optimization}}\label{os_zero_page_optimization}

\texttt{os\_zero\_page\_optimization} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_zero\_page\_optimization $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_zero\_page\_optimization |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_zram\_compress\_ratio}}{os\_zram\_compress\_ratio}}\label{os_zram_compress_ratio}

\texttt{os\_zram\_compress\_ratio} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_zram\_compress\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_zram\_compress\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{os\_zswap\_compress\_ratio}}{os\_zswap\_compress\_ratio}}\label{os_zswap_compress_ratio}

\texttt{os\_zswap\_compress\_ratio} --- batch 50 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = os\_zswap\_compress\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map os\_zswap\_compress\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{osmotic\_coefficient\_pitzer}}{osmotic\_coefficient\_pitzer}}\label{osmotic_coefficient_pitzer}

\texttt{osmotic\_coefficient\_pitzer} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = osmotic\_coefficient\_pitzer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map osmotic\_coefficient\_pitzer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{osmotic\_pressure}}{osmotic\_pressure}}\label{osmotic_pressure}

\texttt{osmotic\_pressure} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = osmotic\_pressure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map osmotic\_pressure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{otto\_efficiency}}{otto\_efficiency}}\label{otto_efficiency}

\texttt{otto\_efficiency} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = otto\_efficiency $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oursync}}{oursync}}\label{oursync}

Package-global counterpart of \texttt{mysync}. Same
\texttt{Arc\textless{}Mutex\textgreater{}} backing, but the binding is
keyed by the package-qualified stash name (\texttt{Pkg::x}) so all
packages and parallel workers share one cell.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{package Counter}
\NormalTok{oursync $total = 0}
\NormalTok{fn bump \{ $total++ \}}
\NormalTok{package main}
\NormalTok{fan 10000 \{ Counter::bump() \}}
\NormalTok{p $Counter::total   \# 10000}
\end{Highlighting}
\end{Shaded}

Use \texttt{oursync} for cross-package shared state; use \texttt{mysync}
for lexically scoped shared state.

\section{\texorpdfstring{\texttt{out\_degree\_directed}}{out\_degree\_directed}}\label{out_degree_directed}

\texttt{out\_degree\_directed} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = out\_degree\_directed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map out\_degree\_directed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{outer}}{outer}}\label{outer}

\texttt{outer} --- outer product of two vectors. Returns matrix where
M{[}i{]}{[}j{]} = v1{[}i{]} * v2{[}j{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $m = outer([1,2,3], [10,20])  \# [[10,20],[20,40],[30,60]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{outlier\_iqr\_q}}{outlier\_iqr\_q}}\label{outlier_iqr_q}

\texttt{outlier\_iqr\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = outlier\_iqr\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map outlier\_iqr\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{outliers}}{outliers}}\label{outliers}

\texttt{outliers} --- statistics (extended) builtin. Alias for
\texttt{outliers\_iqr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = outliers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map outliers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{outliers\_iqr}}{outliers\_iqr}}\label{outliers_iqr}

\texttt{outliers\_iqr(@data)} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @data = (1, 2, 3, 4, 5, 100)}
\NormalTok{my $out = outliers\_iqr(@data)}
\NormalTok{p @$out   \# (100)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ovals}}{ovals}}\label{ovals}

\texttt{ovals} --- javascript array/object methods builtin. Alias for
\texttt{object\_values}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ovals $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ovals |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{overall\_efficiency\_pec}}{overall\_efficiency\_pec}}\label{overall_efficiency_pec}

\texttt{overall\_efficiency\_pec} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = overall\_efficiency\_pec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map overall\_efficiency\_pec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{overlap\_coefficient}}{overlap\_coefficient}}\label{overlap_coefficient}

\texttt{overlap\_coefficient} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = overlap\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map overlap\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{overlapcoef}}{overlapcoef}}\label{overlapcoef}

\texttt{overlapcoef} --- extended stdlib batch 3 builtin. Alias for
\texttt{overlap\_coefficient}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = overlapcoef $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map overlapcoef |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{overline}}{overline}}\label{overline}

\texttt{overline} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = overline $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map overline |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{overpotential\_her}}{overpotential\_her}}\label{overpotential_her}

\texttt{overpotential\_her} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = overpotential\_her $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map overpotential\_her |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{overpotential\_oer}}{overpotential\_oer}}\label{overpotential_oer}

\texttt{overpotential\_oer} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = overpotential\_oer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map overpotential\_oer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{owen\_t}}{owen\_t}}\label{owen_t}

\texttt{owen\_t} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = owen\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map owen\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{owens\_t}}{owens\_t}}\label{owens_t}

\texttt{owens\_t} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = owens\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map owens\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oxidation\_number}}{oxidation\_number}}\label{oxidation_number}

\texttt{oxidation\_number} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oxidation\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map oxidation\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{oz\_to\_g}}{oz\_to\_g}}\label{oz_to_g}

\texttt{oz\_to\_g} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = oz\_to\_g $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ozone\_dobson\_total}}{ozone\_dobson\_total}}\label{ozone_dobson_total}

\texttt{ozone\_dobson\_total} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ozone\_dobson\_total $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ozone\_dobson\_total |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ozsvath\_szabo\_tau}}{ozsvath\_szabo\_tau}}\label{ozsvath_szabo_tau}

\texttt{ozsvath\_szabo\_tau} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ozsvath\_szabo\_tau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ozsvath\_szabo\_tau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pa\_to\_atm}}{pa\_to\_atm}}\label{pa_to_atm}

\texttt{pa\_to\_atm} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pa\_to\_atm $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pacf}}{pacf}}\label{pacf}

\texttt{pacf\_fn} (alias \texttt{pacf}) --- partial autocorrelation
function via Durbin-Levinson. Like R\textquotesingle s pacf().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @pa = @\{pacf([1,3,2,4,3,5], 3)\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pacf\_basis}}{pacf\_basis}}\label{pacf_basis}

\texttt{pacf\_basis} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pacf\_basis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pacf\_basis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{packrat\_parse\_step}}{packrat\_parse\_step}}\label{packrat_parse_step}

\texttt{packrat\_parse\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = packrat\_parse\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map packrat\_parse\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pad\_left}}{pad\_left}}\label{pad_left}

\texttt{pad\_left} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pad\_left $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pad\_left |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pad\_number}}{pad\_number}}\label{pad_number}

\texttt{pad\_number} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pad\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pad\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pad\_right}}{pad\_right}}\label{pad_right}

\texttt{pad\_right} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pad\_right $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pad\_right |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{page\_size}}{page\_size}}\label{page_size}

\texttt{page\_size} --- memory page size in bytes. Uses
\texttt{sysconf(\_SC\_PAGESIZE)} on unix.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p page\_size                              \# 16384 (Apple Silicon)}
\NormalTok{p page\_size                              \# 4096 (x86\_64)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pagerank\_damped}}{pagerank\_damped}}\label{pagerank_damped}

\texttt{pagerank\_damped} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pagerank\_damped $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pagerank\_damped |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pagerank\_iter}}{pagerank\_iter}}\label{pagerank_iter}

\texttt{pagerank\_iter} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pagerank\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pagerank\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{paired\_ttest}}{paired\_ttest}}\label{paired_ttest}

\texttt{paired\_ttest} (alias \texttt{pairedt}) performs a paired t-test
on two matched samples. Returns {[}t-statistic, degrees of freedom{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($t, $df) = @\{pairedt([85,90,78], [88,92,80])\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairs\_from\_hash}}{pairs\_from\_hash}}\label{pairs_from_hash}

\texttt{pairs\_from\_hash} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pairs\_from\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pairs\_from\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairwise}}{pairwise}}\label{pairwise}

\texttt{pairwise} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pairwise $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pairwise |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pairwise\_iter}}{pairwise\_iter}}\label{pairwise_iter}

\texttt{pairwise\_iter} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pairwise\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pairwise\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{palindromic\_q}}{palindromic\_q}}\label{palindromic_q}

\texttt{palindromic\_q} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = palindromic\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map palindromic\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pall}}{pall}}\label{pall}

\texttt{pall} --- algebraic match builtin. Alias for
\texttt{partition\_all}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pall $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pall |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pam250\_score}}{pam250\_score}}\label{pam250_score}

\texttt{pam250\_score} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pam250\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pam250\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{panel\_between\_estimator}}{panel\_between\_estimator}}\label{panel_between_estimator}

\texttt{panel\_between\_estimator} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = panel\_between\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map panel\_between\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{panel\_random\_effects}}{panel\_random\_effects}}\label{panel_random_effects}

\texttt{panel\_random\_effects} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = panel\_random\_effects $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map panel\_random\_effects |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{panel\_var\_step}}{panel\_var\_step}}\label{panel_var_step}

\texttt{panel\_var\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = panel\_var\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map panel\_var\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{panel\_within\_estimator}}{panel\_within\_estimator}}\label{panel_within_estimator}

\texttt{panel\_within\_estimator} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = panel\_within\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map panel\_within\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parabolic\_d0}}{parabolic\_d0}}\label{parabolic_d0}

\texttt{parabolic\_d0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parabolic\_d0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parabolic\_d0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parabolic\_d1}}{parabolic\_d1}}\label{parabolic_d1}

\texttt{parabolic\_d1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parabolic\_d1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parabolic\_d1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parallax\_correction}}{parallax\_correction}}\label{parallax_correction}

\texttt{parallax\_correction} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parallax\_correction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parallax\_correction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parallel\_machine\_lpt}}{parallel\_machine\_lpt}}\label{parallel_machine_lpt}

\texttt{parallel\_machine\_lpt} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parallel\_machine\_lpt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parallel\_machine\_lpt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parallel\_machine\_spt}}{parallel\_machine\_spt}}\label{parallel_machine_spt}

\texttt{parallel\_machine\_spt} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parallel\_machine\_spt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parallel\_machine\_spt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parallel\_transport\_step}}{parallel\_transport\_step}}\label{parallel_transport_step}

\texttt{parallel\_transport\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parallel\_transport\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parallel\_transport\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parenthesize}}{parenthesize}}\label{parenthesize}

\texttt{parenthesize} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parenthesize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parenthesize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pareto\_dominance}}{pareto\_dominance}}\label{pareto_dominance}

\texttt{pareto\_dominance} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pareto\_dominance $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pareto\_efficiency}}{pareto\_efficiency}}\label{pareto_efficiency}

\texttt{pareto\_efficiency} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pareto\_efficiency $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pareto\_pdf}}{pareto\_pdf}}\label{pareto_pdf}

\texttt{pareto\_pdf} (alias \texttt{paretopdf}) evaluates the Pareto
distribution PDF at x with minimum xm and shape alpha.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p paretopdf(2, 1, 3)  \# Pareto(1,3) at x=2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parse\_bool}}{parse\_bool}}\label{parse_bool}

\texttt{parse\_bool} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parse\_bool $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parse\_bool |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parse\_float}}{parse\_float}}\label{parse_float}

\texttt{parse\_float} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parse\_float $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parse\_float |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parse\_int}}{parse\_int}}\label{parse_int}

\texttt{parse\_int} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parse\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parse\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partial\_pressure}}{partial\_pressure}}\label{partial_pressure}

\texttt{partial\_pressure} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partial\_pressure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partial\_pressure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{particle\_filter\_resample}}{particle\_filter\_resample}}\label{particle_filter_resample}

\texttt{particle\_filter\_resample} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = particle\_filter\_resample $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map particle\_filter\_resample |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_all}}{partition\_all}}\label{partition_all}

\texttt{partition\_all} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_at}}{partition\_at}}\label{partition_at}

\texttt{partition\_at} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_by}}{partition\_by}}\label{partition_by}

\texttt{partition\_by} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_either}}{partition\_either}}\label{partition_either}

\texttt{partition\_either} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_either $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_either |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_n}}{partition\_n}}\label{partition_n}

\texttt{partition\_n} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_number}}{partition\_number}}\label{partition_number}

\texttt{partition\_number} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_point}}{partition\_point}}\label{partition_point}

\texttt{partition\_point} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partition\_two}}{partition\_two}}\label{partition_two}

\texttt{partition\_two} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partition\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partition\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partn}}{partn}}\label{partn}

\texttt{partn} --- go/general functional utilities builtin. Alias for
\texttt{partition\_n}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{partn\_num}}{partn\_num}}\label{partn_num}

\texttt{partn\_num} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{partition\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = partn\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map partn\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{parzen\_window}}{parzen\_window}}\label{parzen_window}

\texttt{parzen\_window} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = parzen\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map parzen\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pascal\_case}}{pascal\_case}}\label{pascal_case}

\texttt{pascal\_case} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pascal\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pascal\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pascal\_row}}{pascal\_row}}\label{pascal_row}

\texttt{pascal\_row} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pascal\_row $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pascal\_row |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pascals\_to\_bar}}{pascals\_to\_bar}}\label{pascals_to_bar}

\texttt{pascals\_to\_bar} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pascals\_to\_bar $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pascals\_to\_psi}}{pascals\_to\_psi}}\label{pascals_to_psi}

\texttt{pascals\_to\_psi} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pascals\_to\_psi $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pascals\_triangle}}{pascals\_triangle}}\label{pascals_triangle}

\texttt{pascals\_triangle} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pascals\_triangle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pascals\_triangle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pascrow}}{pascrow}}\label{pascrow}

\texttt{pascrow} --- extended stdlib batch 3 builtin. Alias for
\texttt{pascal\_row}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pascrow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pascrow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pasctri}}{pasctri}}\label{pasctri}

\texttt{pasctri} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{pascals\_triangle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pasctri $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pasctri |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pass}}{pass}}\label{pass}

\texttt{pass} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_case}}{path\_case}}\label{path_case}

\texttt{path\_case} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_dubins\_lsl}}{path\_dubins\_lsl}}\label{path_dubins_lsl}

\texttt{path\_dubins\_lsl} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_dubins\_lsl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_dubins\_lsl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_dubins\_rsr}}{path\_dubins\_rsr}}\label{path_dubins_rsr}

\texttt{path\_dubins\_rsr} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_dubins\_rsr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_dubins\_rsr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_ext}}{path\_ext}}\label{path_ext}

\texttt{path\_ext} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_ext $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_ext |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_is\_abs}}{path\_is\_abs}}\label{path_is_abs}

\texttt{path\_is\_abs} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_is\_abs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_is\_abs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_is\_rel}}{path\_is\_rel}}\label{path_is_rel}

\texttt{path\_is\_rel} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_is\_rel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_is\_rel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_join}}{path\_join}}\label{path_join}

\texttt{path\_join} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_join $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_join |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_parent}}{path\_parent}}\label{path_parent}

\texttt{path\_parent} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_parent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_parent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_reeds\_shepp}}{path\_reeds\_shepp}}\label{path_reeds_shepp}

\texttt{path\_reeds\_shepp} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_reeds\_shepp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_reeds\_shepp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_split}}{path\_split}}\label{path_split}

\texttt{path\_split} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{path\_stem}}{path\_stem}}\label{path_stem}

\texttt{path\_stem} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = path\_stem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map path\_stem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pauli\_decomposition\_2x2}}{pauli\_decomposition\_2x2}}\label{pauli_decomposition_2x2}

\texttt{pauli\_decomposition\_2x2} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pauli\_decomposition\_2x2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pauli\_decomposition\_2x2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pauli\_real\_part}}{pauli\_real\_part}}\label{pauli_real_part}

\texttt{pauli\_real\_part} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pauli\_real\_part $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pauli\_real\_part |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pauli\_string\_expect}}{pauli\_string\_expect}}\label{pauli_string_expect}

\texttt{pauli\_string\_expect} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pauli\_string\_expect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pauli\_string\_expect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pauli\_y\_imag}}{pauli\_y\_imag}}\label{pauli_y_imag}

\texttt{pauli\_y\_imag} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pauli\_y\_imag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pauli\_y\_imag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{payback}}{payback}}\label{payback}

\texttt{payback\_period(\$initial,\ @cashflows)} (alias
\texttt{payback}) --- computes the number of periods to recover initial
investment. Returns fractional periods.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p payback(1000, 300, 400, 500)   \# 2.6 periods}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{payback\_period\_simple}}{payback\_period\_simple}}\label{payback_period_simple}

\texttt{payback\_period\_simple} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = payback\_period\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map payback\_period\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{payback\_simple}}{payback\_simple}}\label{payback_simple}

\texttt{payback\_simple} --- batch 10 builtin. Alias for
\texttt{payback\_period\_simple}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = payback\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map payback\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pbeta}}{pbeta}}\label{pbeta}

\texttt{pbeta} --- beta CDF (regularized incomplete beta). Args: x, a,
b.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pbeta(0.5, 2, 5)  \# P(X ≤ 0.5) for Beta(2,5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pbinom}}{pbinom}}\label{pbinom}

\texttt{pbinom} --- binomial CDF. P(X ≤ k) for Binom(n, p). Args: k, n,
p.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pbinom(5, 10, 0.5)   \# P(≤5 heads in 10 flips)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pbkdf2\_hmac\_step}}{pbkdf2\_hmac\_step}}\label{pbkdf2_hmac_step}

\texttt{pbkdf2\_hmac\_step} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pbkdf2\_hmac\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pbkdf2\_hmac\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pbool}}{pbool}}\label{pbool}

\texttt{pbool} --- extended stdlib builtin. Alias for
\texttt{parse\_bool}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pbool $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pbool |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pby}}{pby}}\label{pby}

\texttt{pby} --- algebraic match builtin. Alias for
\texttt{partition\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pc\_case}}{pc\_case}}\label{pc_case}

\texttt{pc\_case} --- string (batch 2) builtin. Alias for
\texttt{pascal\_case}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pc\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pc\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pc\_to\_au}}{pc\_to\_au}}\label{pc_to_au}

\texttt{pc\_to\_au} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pc\_to\_au $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pc\_to\_ly}}{pc\_to\_ly}}\label{pc_to_ly}

\texttt{pc\_to\_ly} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pc\_to\_ly $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pca}}{pca}}\label{pca}

\texttt{prcomp} (alias \texttt{pca}) --- Principal Component Analysis
via eigendecomposition of covariance matrix. Returns eigenvalues
(variance explained). Like R\textquotesingle s prcomp().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @var = @\{pca([[1,2],[3,4],[5,6],[7,8]])\}}
\NormalTok{\# variance explained by each component}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pcauchy}}{pcauchy}}\label{pcauchy}

\texttt{pcauchy} --- Cauchy CDF. P(X ≤ x). Args: x {[}, location,
scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pcauchy(0, 0, 1)  \# 0.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pcg32\_step}}{pcg32\_step}}\label{pcg32_step}

\texttt{pcg32\_step} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pcg32\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pcg32\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pchisq}}{pchisq}}\label{pchisq}

\texttt{pchisq} --- chi-squared CDF. Args: x, df.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pchisq(3.84, 1)  \# 0.95 (critical value for p=0.05)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pcr}}{pcr}}\label{pcr}

\texttt{pcr} --- data / network builtin. Alias for
\texttt{par\_csv\_read}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pcr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pcr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pct}}{pct}}\label{pct}

\texttt{pct} --- trivial numeric / predicate builtins builtin. Alias for
\texttt{percent}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pctrank}}{pctrank}}\label{pctrank}

\texttt{pctrank} --- statistics (extended) builtin. Alias for
\texttt{percentile\_rank}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pctrank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pctrank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pdo\_index\_step}}{pdo\_index\_step}}\label{pdo_index_step}

\texttt{pdo\_index\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pdo\_index\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pdo\_index\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peak\_detect}}{peak\_detect}}\label{peak_detect}

\texttt{peak\_detect} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peak\_detect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peak\_detect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peak\_widths\_at}}{peak\_widths\_at}}\label{peak_widths_at}

\texttt{peak\_widths\_at} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peak\_widths\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peak\_widths\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peaks}}{peaks}}\label{peaks}

\texttt{peaks} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{peak\_detect}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peaks $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peaks |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pearson\_hash}}{pearson\_hash}}\label{pearson_hash}

\texttt{pearson\_hash} --- batch 9 builtin. Alias for
\texttt{pearson\_hash\_byte}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pearson\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pearson\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pearson\_hash\_byte}}{pearson\_hash\_byte}}\label{pearson_hash_byte}

\texttt{pearson\_hash\_byte} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pearson\_hash\_byte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pearson\_hash\_byte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pearson\_skewness\_2}}{pearson\_skewness\_2}}\label{pearson_skewness_2}

\texttt{pearson\_skewness\_2} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pearson\_skewness\_2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pearson\_skewness\_2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pearsonr}}{pearsonr}}\label{pearsonr}

\texttt{pearsonr} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pearsonr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pearsonr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peclet\_number\_step}}{peclet\_number\_step}}\label{peclet_number_step}

\texttt{peclet\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peclet\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peclet\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peek\_clj}}{peek\_clj}}\label{peek_clj}

\texttt{peek\_clj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peek\_clj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peek\_clj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peeling\_step\_psi4}}{peeling\_step\_psi4}}\label{peeling_step_psi4}

\texttt{peeling\_step\_psi4} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peeling\_step\_psi4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peeling\_step\_psi4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peg\_choice}}{peg\_choice}}\label{peg_choice}

\texttt{peg\_choice} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peg\_choice $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peg\_choice |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peg\_lookahead}}{peg\_lookahead}}\label{peg_lookahead}

\texttt{peg\_lookahead} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peg\_lookahead $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peg\_lookahead |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peg\_repeat}}{peg\_repeat}}\label{peg_repeat}

\texttt{peg\_repeat} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peg\_repeat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peg\_repeat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peg\_seq}}{peg\_seq}}\label{peg_seq}

\texttt{peg\_seq} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peg\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peg\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peith}}{peith}}\label{peith}

\texttt{peith} --- rust iterator methods builtin. Alias for
\texttt{partition\_either}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peith $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peith |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pell\_fundamental}}{pell\_fundamental}}\label{pell_fundamental}

\texttt{pell\_fundamental} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pell\_fundamental $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pell\_fundamental |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pendper}}{pendper}}\label{pendper}

\texttt{pendulum\_period(\$length)} (alias \texttt{pendper}) --- period
T = 2π√(L/g) of a simple pendulum.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pendper(1)      \# \textasciitilde{}2.01 s (1 meter pendulum)}
\NormalTok{p pendper(0.25)   \# \textasciitilde{}1.00 s (grandfather clock)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pendulum\_freq}}{pendulum\_freq}}\label{pendulum_freq}

\texttt{pendulum\_freq} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pendulum\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pendulum\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{penrose\_diagram\_factor}}{penrose\_diagram\_factor}}\label{penrose_diagram_factor}

\texttt{penrose\_diagram\_factor} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = penrose\_diagram\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map penrose\_diagram\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pentagonal\_number}}{pentagonal\_number}}\label{pentagonal_number}

\texttt{pentagonal\_number} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pentagonal\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pentagonal\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pentagonal\_pyramidal\_number}}{pentagonal\_pyramidal\_number}}\label{pentagonal_pyramidal_number}

\texttt{pentagonal\_pyramidal\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pentagonal\_pyramidal\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pentagonal\_pyramidal\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pentnum}}{pentnum}}\label{pentnum}

\texttt{pentnum} --- number theory / primes builtin. Alias for
\texttt{pentagonal\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pentnum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pentnum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percent}}{percent}}\label{percent}

\texttt{percent} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percent\_decode\_url}}{percent\_decode\_url}}\label{percent_decode_url}

\texttt{percent\_decode\_url} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percent\_decode\_url $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percent\_decode\_url |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percent\_encode\_full}}{percent\_encode\_full}}\label{percent_encode_full}

\texttt{percent\_encode\_full} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percent\_encode\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percent\_encode\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percentile}}{percentile}}\label{percentile}

\texttt{percentile} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percentile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percentile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percentile\_cont}}{percentile\_cont}}\label{percentile_cont}

\texttt{percentile\_cont} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percentile\_cont $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percentile\_cont |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percentile\_disc}}{percentile\_disc}}\label{percentile_disc}

\texttt{percentile\_disc} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percentile\_disc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percentile\_disc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percentile\_rank}}{percentile\_rank}}\label{percentile_rank}

\texttt{percentile\_rank(\$value,\ @data)} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @scores = 1:100}
\NormalTok{p percentile\_rank(50, @scores)   \# \textasciitilde{}50}
\NormalTok{p percentile\_rank(90, @scores)   \# \textasciitilde{}90}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{percentrank}}{percentrank}}\label{percentrank}

\texttt{percentrank} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = percentrank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map percentrank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perfect\_numbers}}{perfect\_numbers}}\label{perfect_numbers}

\texttt{perfect\_numbers} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perfect\_numbers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perfect\_numbers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perfnums}}{perfnums}}\label{perfnums}

\texttt{perfnums} --- number theory / primes builtin. Alias for
\texttt{perfect\_numbers}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perfnums $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perfnums |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perihelion\_precession}}{perihelion\_precession}}\label{perihelion_precession}

\texttt{perihelion\_precession} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perihelion\_precession $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perihelion\_precession |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perimeter\_rectangle}}{perimeter\_rectangle}}\label{perimeter_rectangle}

\texttt{perimeter\_rectangle} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perimeter\_rectangle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perimeter\_rectangle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perimeter\_triangle}}{perimeter\_triangle}}\label{perimeter_triangle}

\texttt{perimeter\_triangle} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perimeter\_triangle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perimeter\_triangle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{period\_of\_string}}{period\_of\_string}}\label{period_of_string}

\texttt{period\_of\_string} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = period\_of\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map period\_of\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{periodogram\_basic}}{periodogram\_basic}}\label{periodogram_basic}

\texttt{periodogram\_basic} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = periodogram\_basic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map periodogram\_basic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perm}}{perm}}\label{perm}

\texttt{permutations(\$n,\ \$r)} (alias \texttt{perm}) --- number of
ways to arrange r items from n. Formula: n!/(n-r)!. Order matters.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p perm(5, 3)    \# 60 (ways to arrange 3 items from 5)}
\NormalTok{p perm(10, 2)   \# 90}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perm\_mul}}{perm\_mul}}\label{perm_mul}

\texttt{perm\_mul} --- batch 9 builtin. Alias for
\texttt{permutation\_compose}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perm\_mul $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perm\_mul |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perm\_sign}}{perm\_sign}}\label{perm_sign}

\texttt{perm\_sign} --- batch 9 builtin. Alias for
\texttt{permutation\_parity}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perm\_sign $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perm\_sign |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{permutation\_compose}}{permutation\_compose}}\label{permutation_compose}

\texttt{permutation\_compose} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = permutation\_compose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map permutation\_compose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{permutation\_order}}{permutation\_order}}\label{permutation_order}

\texttt{permutation\_order} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = permutation\_order $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map permutation\_order |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{permutation\_parity}}{permutation\_parity}}\label{permutation_parity}

\texttt{permutation\_parity} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = permutation\_parity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map permutation\_parity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{permute\_idx}}{permute\_idx}}\label{permute_idx}

\texttt{permute\_idx} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = permute\_idx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map permute\_idx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{perpetuity\_value}}{perpetuity\_value}}\label{perpetuity_value}

\texttt{perpetuity\_value} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = perpetuity\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map perpetuity\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{persian\_arithmetic\_leap}}{persian\_arithmetic\_leap}}\label{persian_arithmetic_leap}

\texttt{persian\_arithmetic\_leap} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = persian\_arithmetic\_leap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map persian\_arithmetic\_leap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{persist}}{persist}}\label{persist}

\texttt{persist} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = persist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map persist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{personalized\_pagerank}}{personalized\_pagerank}}\label{personalized_pagerank}

\texttt{personalized\_pagerank} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = personalized\_pagerank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map personalized\_pagerank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{petersen\_estimator}}{petersen\_estimator}}\label{petersen_estimator}

\texttt{petersen\_estimator} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = petersen\_estimator $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map petersen\_estimator |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peukert\_capacity}}{peukert\_capacity}}\label{peukert_capacity}

\texttt{peukert\_capacity} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peukert\_capacity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peukert\_capacity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{peukert\_exponent\_fit}}{peukert\_exponent\_fit}}\label{peukert_exponent_fit}

\texttt{peukert\_exponent\_fit} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = peukert\_exponent\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map peukert\_exponent\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pexp}}{pexp}}\label{pexp}

\texttt{pexp} --- exponential CDF. P(X ≤ x) for Exp(rate). Args: x,
rate.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pexp(1, 1)     \# 0.6321 (1 {-} e\^{}{-}1)}
\NormalTok{p pexp(5, 0.5)   \# P(wait ≤ 5 with avg wait 2)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pf}}{pf}}\label{pf}

\texttt{pf} --- F-distribution CDF. Args: x, d1, d2.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pf(4.0, 5, 10)  \# P(F ≤ 4) for F(5,10)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfact}}{pfact}}\label{pfact}

\texttt{pfact} --- number theory / primes builtin. Alias for
\texttt{prime\_factors}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pfact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pfact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfadd}}{pfadd}}\label{pfadd}

\texttt{pfadd} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pfadd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pfadd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfcount}}{pfcount}}\label{pfcount}

\texttt{pfcount} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pfcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pfcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pflt}}{pflt}}\label{pflt}

\texttt{pflt} --- extended stdlib builtin. Alias for
\texttt{parse\_float}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pflt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pflt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfreq}}{pfreq}}\label{pfreq}

\texttt{pfreq} --- pipeline / string helpers builtin. Alias for
\texttt{pfrequencies}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pfreq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pfreq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfrequencies}}{pfrequencies}}\label{pfrequencies}

\texttt{pfrequencies} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pfrequencies $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pfrequencies |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pfrq}}{pfrq}}\label{pfrq}

\texttt{pfrq} --- pipeline / string helpers builtin. Alias for
\texttt{pfrequencies}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pfrq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pfrq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pft}}{pft}}\label{pft}

\texttt{pft} --- data / network builtin. Alias for \texttt{par\_fetch}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pft $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pft |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pga\_attenuation}}{pga\_attenuation}}\label{pga_attenuation}

\texttt{pga\_attenuation} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pga\_attenuation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pga\_attenuation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pgamma}}{pgamma}}\label{pgamma}

\texttt{pgamma} --- gamma CDF. Args: x, shape {[}, scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pgamma(2, 2, 1)  \# P(X ≤ 2) for Gamma(2,1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ph\_at\_isoelectric}}{ph\_at\_isoelectric}}\label{ph_at_isoelectric}

\texttt{ph\_at\_isoelectric} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ph\_at\_isoelectric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ph\_at\_isoelectric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ph\_from\_h}}{ph\_from\_h}}\label{ph_from_h}

\texttt{ph\_from\_h} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ph\_from\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ph\_from\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{phase\_flip\_prob}}{phase\_flip\_prob}}\label{phase_flip_prob}

\texttt{phase\_flip\_prob} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = phase\_flip\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map phase\_flip\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{phase\_spectrum}}{phase\_spectrum}}\label{phase_spectrum}

\texttt{phase\_spectrum(\textbackslash{}@signal)} --- computes the phase
angle (in radians) at each frequency bin from the DFT.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $phases = phase\_spectrum(\textbackslash{}@signal)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{phasespec}}{phasespec}}\label{phasespec}

\texttt{phasespec} --- dsp / signal (extended) builtin. Alias for
\texttt{phase\_spectrum}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = phasespec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map phasespec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{phillips\_perron}}{phillips\_perron}}\label{phillips_perron}

\texttt{phillips\_perron} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = phillips\_perron $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map phillips\_perron |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{phonedigit}}{phonedigit}}\label{phonedigit}

\texttt{phonedigit} --- encoding / phonetics builtin. Alias for
\texttt{phonetic\_digit}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = phonedigit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map phonedigit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{phonetic\_digit}}{phonetic\_digit}}\label{phonetic_digit}

\texttt{phonetic\_digit} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = phonetic\_digit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map phonetic\_digit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photocurrent\_density}}{photocurrent\_density}}\label{photocurrent_density}

\texttt{photocurrent\_density} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = photocurrent\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map photocurrent\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photon\_energy}}{photon\_energy}}\label{photon_energy}

\texttt{photon\_energy(\$frequency)} (alias \texttt{photonenergy}) ---
energy E = hf (Joules) of a photon.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p photonenergy(5e14)   \# \textasciitilde{}3.3e{-}19 J (visible light)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photon\_energy\_freq}}{photon\_energy\_freq}}\label{photon_energy_freq}

\texttt{photon\_energy\_freq} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = photon\_energy\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map photon\_energy\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photon\_energy\_lambda}}{photon\_energy\_lambda}}\label{photon_energy_lambda}

\texttt{photon\_energy\_lambda} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = photon\_energy\_lambda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map photon\_energy\_lambda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photon\_energy\_wavelength}}{photon\_energy\_wavelength}}\label{photon_energy_wavelength}

\texttt{photon\_energy\_wavelength} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = photon\_energy\_wavelength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map photon\_energy\_wavelength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photon\_sphere\_radius}}{photon\_sphere\_radius}}\label{photon_sphere_radius}

\texttt{photon\_sphere\_radius} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = photon\_sphere\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map photon\_sphere\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{photonlambda}}{photonlambda}}\label{photonlambda}

\texttt{photonlambda} --- physics formulas builtin. Alias for
\texttt{photon\_energy\_wavelength}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = photonlambda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map photonlambda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pi}}{pi}}\label{pi}

\texttt{pi} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pi\_step\_size}}{pi\_step\_size}}\label{pi_step_size}

\texttt{pi\_step\_size} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pi\_step\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pi\_step\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pick}}{pick}}\label{pick}

\texttt{pick} --- hash ops (batch 2) builtin. Alias for
\texttt{pick\_keys}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pick $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pick |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pick\_keys}}{pick\_keys}}\label{pick_keys}

\texttt{pick\_keys} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pick\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pick\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{picks\_theorem}}{picks\_theorem}}\label{picks_theorem}

\texttt{picks\_theorem} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = picks\_theorem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map picks\_theorem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pid}}{pid}}\label{pid}

\texttt{pid} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pid\_anti\_windup}}{pid\_anti\_windup}}\label{pid_anti_windup}

\texttt{pid\_anti\_windup} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pid\_anti\_windup $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pid\_anti\_windup |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pid\_ziegler\_nichols}}{pid\_ziegler\_nichols}}\label{pid_ziegler_nichols}

\texttt{pid\_ziegler\_nichols} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pid\_ziegler\_nichols $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pid\_ziegler\_nichols |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pielou\_evenness}}{pielou\_evenness}}\label{pielou_evenness}

\texttt{pielou\_evenness} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pielou\_evenness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pielou\_evenness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pig\_latin}}{pig\_latin}}\label{pig_latin}

\texttt{pig\_latin} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pig\_latin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pig\_latin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{piglat}}{piglat}}\label{piglat}

\texttt{piglat} --- string processing (uncategorized batch) builtin.
Alias for \texttt{pig\_latin}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = piglat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map piglat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pin}}{pin}}\label{pin}

\texttt{pin} --- stress testing builtin. Alias for
\texttt{fire\_and\_forget}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pint}}{pint}}\label{pint}

\texttt{pint} --- extended stdlib builtin. Alias for
\texttt{parse\_int}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pipe\_pressure\_drop}}{pipe\_pressure\_drop}}\label{pipe_pressure_drop}

\texttt{pipe\_pressure\_drop} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pipe\_pressure\_drop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pipe\_pressure\_drop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pipes}}{pipes}}\label{pipes}

\texttt{pipes} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pipes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pipes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pivoted\_cholesky\_var}}{pivoted\_cholesky\_var}}\label{pivoted_cholesky_var}

\texttt{pivoted\_cholesky\_var} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pivoted\_cholesky\_var $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pivoted\_cholesky\_var |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pka\_from\_ka}}{pka\_from\_ka}}\label{pka_from_ka}

\texttt{pka\_from\_ka} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pka\_from\_ka $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pka\_from\_ka |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pkb\_to\_kb}}{pkb\_to\_kb}}\label{pkb_to_kb}

\texttt{pkb\_to\_kb} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pkb\_to\_kb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pkc}}{pkc}}\label{pkc}

\texttt{pkc} --- algebraic match builtin. Alias for \texttt{peek\_clj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pkc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pkc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pkcs7\_pad}}{pkcs7\_pad}}\label{pkcs7_pad}

\texttt{pkcs7\_pad} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pkcs7\_pad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pkcs7\_pad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pkcs7\_unpad}}{pkcs7\_unpad}}\label{pkcs7_unpad}

\texttt{pkcs7\_unpad} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pkcs7\_unpad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pkcs7\_unpad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plactic\_class\_size}}{plactic\_class\_size}}\label{plactic_class_size}

\texttt{plactic\_class\_size} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plactic\_class\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plactic\_class\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck}}{planck}}\label{planck}

\texttt{planck} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_const\_h}}{planck\_const\_h}}\label{planck_const_h}

\texttt{planck\_const\_h} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_const\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_const\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_constant}}{planck\_constant}}\label{planck_constant}

\texttt{planck\_constant} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_energy}}{planck\_energy}}\label{planck_energy}

\texttt{planck\_energy} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_mass}}{planck\_mass}}\label{planck_mass}

\texttt{planck\_mass} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_spectral\_radiance}}{planck\_spectral\_radiance}}\label{planck_spectral_radiance}

\texttt{planck\_spectral\_radiance} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_spectral\_radiance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_spectral\_radiance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_temperature}}{planck\_temperature}}\label{planck_temperature}

\texttt{planck\_temperature} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_temperature $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_temperature |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{planck\_time}}{planck\_time}}\label{planck_time}

\texttt{planck\_time} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = planck\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map planck\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plastic}}{plastic}}\label{plastic}

\texttt{plastic} --- math constants builtin. Alias for
\texttt{plastic\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plastic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plastic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plastic\_number}}{plastic\_number}}\label{plastic_number}

\texttt{plastic\_number} --- math constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plastic\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plastic\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plethystic\_substitution\_value}}{plethystic\_substitution\_value}}\label{plethystic_substitution_value}

\texttt{plethystic\_substitution\_value} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plethystic\_substitution\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plethystic\_substitution\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plnorm}}{plnorm}}\label{plnorm}

\texttt{plnorm} --- log-normal CDF. P(X ≤ x) for LogN(mu, sigma). Args:
x, mu, sigma.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p plnorm(1, 0, 1)   \# 0.5 (median of LogN(0,1))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plur}}{plur}}\label{plur}

\texttt{plur} --- extended stdlib builtin. Alias for \texttt{pluralize}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plur $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plur |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plurality\_winner\_step}}{plurality\_winner\_step}}\label{plurality_winner_step}

\texttt{plurality\_winner\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plurality\_winner\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plurality\_winner\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pluralize}}{pluralize}}\label{pluralize}

\texttt{pluralize} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pluralize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pluralize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pluralize\_simple}}{pluralize\_simple}}\label{pluralize_simple}

\texttt{pluralize\_simple} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pluralize\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pluralize\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{plus\_polarization\_amp}}{plus\_polarization\_amp}}\label{plus_polarization_amp}

\texttt{plus\_polarization\_amp} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = plus\_polarization\_amp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map plus\_polarization\_amp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pmass}}{pmass}}\label{pmass}

\texttt{pmass} --- constants builtin. Alias for \texttt{proton\_mass}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pmass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pmass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pmt}}{pmt}}\label{pmt}

\texttt{pmt(\$rate,\ \$nper,\ \$pv)} --- computes the periodic payment
for a loan given interest rate, number of periods, and present value.
Standard amortization formula.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# $100k loan, 5\% annual rate, 30 years}
\NormalTok{p pmt(0.05/12, 360, 100000)   \# \textasciitilde{}$537/month}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pnorm}}{pnorm}}\label{pnorm}

\texttt{pnorm} --- normal CDF. P(X ≤ x) for N(mu, sigma). Args: x {[},
mu, sigma{]}. Default standard normal.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pnorm(0)          \# 0.5}
\NormalTok{p pnorm(1.96)       \# 0.975}
\NormalTok{p pnorm(100, 90, 15) \# z{-}score for IQ 100}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pochhammer}}{pochhammer}}\label{pochhammer}

\texttt{pochhammer} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pochhammer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pochhammer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poh\_from\_oh}}{poh\_from\_oh}}\label{poh_from_oh}

\texttt{poh\_from\_oh} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poh\_from\_oh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poh\_from\_oh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poincare\_duality}}{poincare\_duality}}\label{poincare_duality}

\texttt{poincare\_duality} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poincare\_duality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poincare\_duality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poincare\_polynomial\_eval}}{poincare\_polynomial\_eval}}\label{poincare_polynomial_eval}

\texttt{poincare\_polynomial\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poincare\_polynomial\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poincare\_polynomial\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{point\_distance}}{point\_distance}}\label{point_distance}

\texttt{point\_distance} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = point\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map point\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{point\_in\_polygon}}{point\_in\_polygon}}\label{point_in_polygon}

\texttt{point\_in\_polygon(\$x,\ \$y,\ @polygon)} (alias \texttt{pip})
--- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @square = (0,0, 4,0, 4,4, 0,4)}
\NormalTok{p pip(2, 2, @square)   \# 1 (inside)}
\NormalTok{p pip(5, 5, @square)   \# 0 (outside)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{point\_in\_polygon\_ray}}{point\_in\_polygon\_ray}}\label{point_in_polygon_ray}

\texttt{point\_in\_polygon\_ray} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = point\_in\_polygon\_ray $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map point\_in\_polygon\_ray |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{point\_in\_polygon\_winding}}{point\_in\_polygon\_winding}}\label{point_in_polygon_winding}

\texttt{point\_in\_polygon\_winding} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = point\_in\_polygon\_winding $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map point\_in\_polygon\_winding |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pointer\_width}}{pointer\_width}}\label{pointer_width}

\texttt{pointer\_width} --- pointer width in bits: \texttt{32} or
\texttt{64}. Compile-time constant.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pointer\_width                          \# 64}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poisson}}{poisson}}\label{poisson}

\texttt{poisson\_pmf(\$k,\ \$lambda)} (alias \texttt{poisson}) ---
Poisson probability mass function. P(X=k) for events with rate λ.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p poisson(3, 5)   \# P(X=3) when avg rate is 5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poisson\_boltzmann\_step}}{poisson\_boltzmann\_step}}\label{poisson_boltzmann_step}

\texttt{poisson\_boltzmann\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poisson\_boltzmann\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poisson\_boltzmann\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poisson\_photon\_pmf}}{poisson\_photon\_pmf}}\label{poisson_photon_pmf}

\texttt{poisson\_photon\_pmf} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poisson\_photon\_pmf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poisson\_photon\_pmf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polar\_vortex\_radius}}{polar\_vortex\_radius}}\label{polar_vortex_radius}

\texttt{polar\_vortex\_radius} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polar\_vortex\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polar\_vortex\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{policy\_iteration\_step}}{policy\_iteration\_step}}\label{policy_iteration_step}

\texttt{policy\_iteration\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = policy\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map policy\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pollard\_p\_minus\_1}}{pollard\_p\_minus\_1}}\label{pollard_p_minus_1}

\texttt{pollard\_p\_minus\_1} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pollard\_p\_minus\_1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pollard\_p\_minus\_1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poly1305\_block\_step}}{poly1305\_block\_step}}\label{poly1305_block_step}

\texttt{poly1305\_block\_step} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poly1305\_block\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poly1305\_block\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poly\_eval}}{poly\_eval}}\label{poly_eval}

\texttt{poly\_eval} (alias \texttt{polyval}) evaluates a polynomial c0 +
c1·x + c2·x² + ... using Horner\textquotesingle s method.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p polyval([1, 0, 1], 3)  \# 1 + 0*3 + 1*9 = 10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polyarea}}{polyarea}}\label{polyarea}

\texttt{polyarea} --- geometry / physics builtin. Alias for
\texttt{polygon\_area}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polyarea $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polyarea |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polyfit}}{polyfit}}\label{polyfit}

\texttt{polynomial\_fit} (alias \texttt{polyfit}) performs least-squares
polynomial fitting. Returns coefficients {[}c0, c1, ..., cn{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $c = polyfit([0,1,2,3], [1,3,5,7], 1)  \# linear fit}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polyfit\_rmse}}{polyfit\_rmse}}\label{polyfit_rmse}

\texttt{polyfit\_rmse} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polyfit\_rmse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polyfit\_rmse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygamma}}{polygamma}}\label{polygamma}

\texttt{polygamma} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygamma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygamma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_area}}{polygon\_area}}\label{polygon_area}

\texttt{polygon\_area} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_area\_signed}}{polygon\_area\_signed}}\label{polygon_area_signed}

\texttt{polygon\_area\_signed} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_area\_signed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_area\_signed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_convex\_q}}{polygon\_convex\_q}}\label{polygon_convex_q}

\texttt{polygon\_convex\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_convex\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_convex\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_is\_convex}}{polygon\_is\_convex}}\label{polygon_is_convex}

\texttt{polygon\_is\_convex} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_is\_convex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_is\_convex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_perimeter}}{polygon\_perimeter}}\label{polygon_perimeter}

\texttt{polygon\_perimeter(@points)} (alias \texttt{polyper}) ---
computes the perimeter of a polygon. Points as flat list
{[}x1,y1,x2,y2,...{]}. Assumes closed polygon.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @square = (0,0, 1,0, 1,1, 0,1)}
\NormalTok{p polyper(@square)   \# 4}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_winding\_number}}{polygon\_winding\_number}}\label{polygon_winding_number}

\texttt{polygon\_winding\_number} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_winding\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_winding\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_winding\_order}}{polygon\_winding\_order}}\label{polygon_winding_order}

\texttt{polygon\_winding\_order} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_winding\_order $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_winding\_order |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polygon\_with\_holes\_area}}{polygon\_with\_holes\_area}}\label{polygon_with_holes_area}

\texttt{polygon\_with\_holes\_area} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polygon\_with\_holes\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polygon\_with\_holes\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polylog\_li2}}{polylog\_li2}}\label{polylog_li2}

\texttt{polylog\_li2} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polylog\_li2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polylog\_li2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polylog\_n}}{polylog\_n}}\label{polylog_n}

\texttt{polylog\_n} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polylog\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polylog\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polynomial\_jones\_skein}}{polynomial\_jones\_skein}}\label{polynomial_jones_skein}

\texttt{polynomial\_jones\_skein} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polynomial\_jones\_skein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polynomial\_jones\_skein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polynomial\_roots\_dk}}{polynomial\_roots\_dk}}\label{polynomial_roots_dk}

\texttt{polynomial\_roots\_dk} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polynomial\_roots\_dk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polynomial\_roots\_dk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{polyperim}}{polyperim}}\label{polyperim}

\texttt{polyperim} --- geometry (extended) builtin. Alias for
\texttt{polygon\_perimeter}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = polyperim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map polyperim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pooling\_test\_stat}}{pooling\_test\_stat}}\label{pooling_test_stat}

\texttt{pooling\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pooling\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pooling\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pop\_clj}}{pop\_clj}}\label{pop_clj}

\texttt{pop\_clj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pop\_clj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pop\_clj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{popc}}{popc}}\label{popc}

\texttt{popc} --- algebraic match builtin. Alias for \texttt{pop\_clj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = popc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map popc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{popcnt}}{popcnt}}\label{popcnt}

\texttt{popcnt} --- batch 10 builtin. Alias for
\texttt{hamming\_weight}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = popcnt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map popcnt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{popcount}}{popcount}}\label{popcount}

\texttt{popcount} --- base conversion builtin. Alias for
\texttt{bits\_count}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = popcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map popcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{porosity\_active\_layer}}{porosity\_active\_layer}}\label{porosity_active_layer}

\texttt{porosity\_active\_layer} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = porosity\_active\_layer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map porosity\_active\_layer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{porter\_stem\_step}}{porter\_stem\_step}}\label{porter_stem_step}

\texttt{porter\_stem\_step} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = porter\_stem\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map porter\_stem\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pos\_n}}{pos\_n}}\label{pos_n}

\texttt{pos\_n} --- trivial numeric / predicate builtins builtin. Alias
for \texttt{positive}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pos\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pos\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poset\_zeta\_two}}{poset\_zeta\_two}}\label{poset_zeta_two}

\texttt{poset\_zeta\_two} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poset\_zeta\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poset\_zeta\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{position\_of\_all\_matching}}{position\_of\_all\_matching}}\label{position_of_all_matching}

\texttt{position\_of\_all\_matching} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = position\_of\_all\_matching $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map position\_of\_all\_matching |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{positions\_of}}{positions\_of}}\label{positions_of}

\texttt{positions\_of} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = positions\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map positions\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{positions\_of\_all}}{positions\_of\_all}}\label{positions_of_all}

\texttt{positions\_of\_all} --- batch 9 builtin. Alias for
\texttt{position\_of\_all\_matching}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = positions\_of\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map positions\_of\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{positive}}{positive}}\label{positive}

\texttt{positive} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = positive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map positive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{post\_newtonian\_step}}{post\_newtonian\_step}}\label{post_newtonian_step}

\texttt{post\_newtonian\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = post\_newtonian\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map post\_newtonian\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{posted\_price\_offer\_accept}}{posted\_price\_offer\_accept}}\label{posted_price_offer_accept}

\texttt{posted\_price\_offer\_accept} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = posted\_price\_offer\_accept $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map posted\_price\_offer\_accept |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{potential\_energy}}{potential\_energy}}\label{potential_energy}

\texttt{potential\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = potential\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map potential\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{potential\_temperature\_step}}{potential\_temperature\_step}}\label{potential_temperature_step}

\texttt{potential\_temperature\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = potential\_temperature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map potential\_temperature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pourbaix\_line\_value}}{pourbaix\_line\_value}}\label{pourbaix_line_value}

\texttt{pourbaix\_line\_value} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pourbaix\_line\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pourbaix\_line\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pow2}}{pow2}}\label{pow2}

\texttt{pow2} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pow2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pow2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_density\_battery}}{power\_density\_battery}}\label{power_density_battery}

\texttt{power\_density\_battery} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_density\_battery $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_density\_battery |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_i2r}}{power\_i2r}}\label{power_i2r}

\texttt{power\_i2r} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_i2r $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_i2r |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_law\_wind\_profile}}{power\_law\_wind\_profile}}\label{power_law_wind_profile}

\texttt{power\_law\_wind\_profile} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_law\_wind\_profile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_law\_wind\_profile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_phys}}{power\_phys}}\label{power_phys}

\texttt{power\_phys} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_phys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_phys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_residue\_check}}{power\_residue\_check}}\label{power_residue_check}

\texttt{power\_residue\_check} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_residue\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_residue\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_set}}{power\_set}}\label{power_set}

\texttt{power\_set} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_set $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_set |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_spectrum}}{power\_spectrum}}\label{power_spectrum}

\texttt{power\_spectrum(\textbackslash{}@signal)} (alias \texttt{psd})
--- computes the power spectral density (magnitude squared of DFT).
Returns real values representing power at each frequency bin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $psd = psd(\textbackslash{}@signal)}
\NormalTok{@$psd |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_spectrum\_slope}}{power\_spectrum\_slope}}\label{power_spectrum_slope}

\texttt{power\_spectrum\_slope} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_spectrum\_slope $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_spectrum\_slope |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{power\_vi}}{power\_vi}}\label{power_vi}

\texttt{power\_vi} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = power\_vi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map power\_vi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{powers\_of\_seq}}{powers\_of\_seq}}\label{powers_of_seq}

\texttt{powers\_of\_seq} --- sequences builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = powers\_of\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map powers\_of\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{powerset}}{powerset}}\label{powerset}

\texttt{powerset} --- extended stdlib batch 3 builtin. Alias for
\texttt{power\_set}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = powerset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map powerset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{powspec}}{powspec}}\label{powspec}

\texttt{powspec} --- dsp / signal (extended) builtin. Alias for
\texttt{power\_spectrum}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = powspec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map powspec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{poynting\_magnitude}}{poynting\_magnitude}}\label{poynting_magnitude}

\texttt{poynting\_magnitude} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = poynting\_magnitude $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map poynting\_magnitude |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pp\_test\_stat}}{pp\_test\_stat}}\label{pp_test_stat}

\texttt{pp\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pp\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pp\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppi}}{ppi}}\label{ppi}

\texttt{ppi} --- number theory / primes builtin. Alias for
\texttt{prime\_pi}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppid}}{ppid}}\label{ppid}

\texttt{ppid} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppm\_predict\_prob}}{ppm\_predict\_prob}}\label{ppm_predict_prob}

\texttt{ppm\_predict\_prob} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppm\_predict\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppm\_predict\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppmt}}{ppmt}}\label{ppmt}

\texttt{ppmt} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppmt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppmt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppo\_advantage\_step}}{ppo\_advantage\_step}}\label{ppo_advantage_step}

\texttt{ppo\_advantage\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppo\_advantage\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppo\_advantage\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppo\_clip\_term}}{ppo\_clip\_term}}\label{ppo_clip_term}

\texttt{ppo\_clip\_term} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppo\_clip\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppo\_clip\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppois}}{ppois}}\label{ppois}

\texttt{ppois} --- Poisson CDF. P(X ≤ k) for Poisson(lambda). Args: k,
lambda.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p ppois(3, 2.5)  \# P(≤3 events when avg is 2.5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ppt}}{ppt}}\label{ppt}

\texttt{ppt} --- extended stdlib builtin. Alias for
\texttt{partition\_point}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ppt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ppt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prandtl\_number\_step}}{prandtl\_number\_step}}\label{prandtl_number_step}

\texttt{prandtl\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prandtl\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prandtl\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pratt\_parse\_step}}{pratt\_parse\_step}}\label{pratt_parse_step}

\texttt{pratt\_parse\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pratt\_parse\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pratt\_parse\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{precession\_iau2006}}{precession\_iau2006}}\label{precession_iau2006}

\texttt{precession\_iau2006} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = precession\_iau2006 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map precession\_iau2006 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prect}}{prect}}\label{prect}

\texttt{prect} --- geometry / physics builtin. Alias for
\texttt{perimeter\_rectangle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pred}}{pred}}\label{pred}

\texttt{pred} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pred $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pred |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{predict}}{predict}}\label{predict}

\texttt{predict\_lm} (alias \texttt{predict}) --- predict from a linear
model at new x values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $model = lm([1,2,3], [2,4,6])}
\NormalTok{my @pred = @\{predict($model, [4,5,6])\}  \# [8,10,12]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{predictor\_corrector}}{predictor\_corrector}}\label{predictor_corrector}

\texttt{predictor\_corrector} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = predictor\_corrector $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map predictor\_corrector |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prefix\_sums}}{prefix\_sums}}\label{prefix_sums}

\texttt{prefix\_sums} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prefix\_sums $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prefix\_sums |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prelu}}{prelu}}\label{prelu}

\texttt{prelu} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prelu $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prelu |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{premium\_net}}{premium\_net}}\label{premium_net}

\texttt{premium\_net} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = premium\_net $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map premium\_net |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prepend}}{prepend}}\label{prepend}

\texttt{prepend} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prepend $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prepend |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{present\_value}}{present\_value}}\label{present_value}

\texttt{present\_value} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = present\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map present\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pressure\_altitude\_m}}{pressure\_altitude\_m}}\label{pressure_altitude_m}

\texttt{pressure\_altitude\_m} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pressure\_altitude\_m $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pressure\_altitude\_m |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prev\_prime}}{prev\_prime}}\label{prev_prime}

\texttt{prev\_prime} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prev\_prime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prev\_prime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{preventive\_fraction}}{preventive\_fraction}}\label{preventive_fraction}

\texttt{preventive\_fraction} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = preventive\_fraction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map preventive\_fraction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prewitt\_kernel\_value}}{prewitt\_kernel\_value}}\label{prewitt_kernel_value}

\texttt{prewitt\_kernel\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prewitt\_kernel\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prewitt\_kernel\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{price\_disc}}{price\_disc}}\label{price_disc}

\texttt{price\_disc} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = price\_disc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map price\_disc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{price\_elasticity}}{price\_elasticity}}\label{price_elasticity}

\texttt{price\_elasticity} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = price\_elasticity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map price\_elasticity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prim\_step}}{prim\_step}}\label{prim_step}

\texttt{prim\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prim\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prim\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prime\_factors}}{prime\_factors}}\label{prime_factors}

\texttt{prime\_factors} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prime\_factors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prime\_factors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prime\_pi}}{prime\_pi}}\label{prime_pi}

\texttt{prime\_pi} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prime\_pi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prime\_pi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{primes\_seq}}{primes\_seq}}\label{primes_seq}

\texttt{primes\_seq} --- sequences builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = primes\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map primes\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{primes\_up\_to}}{primes\_up\_to}}\label{primes_up_to}

\texttt{primes\_up\_to} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = primes\_up\_to $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map primes\_up\_to |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{primorial\_n}}{primorial\_n}}\label{primorial_n}

\texttt{primorial\_n} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = primorial\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map primorial\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prisoners\_dilemma\_payoff}}{prisoners\_dilemma\_payoff}}\label{prisoners_dilemma_payoff}

\texttt{prisoners\_dilemma\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prisoners\_dilemma\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prisoners\_dilemma\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prisoners\_repeated\_eq}}{prisoners\_repeated\_eq}}\label{prisoners_repeated_eq}

\texttt{prisoners\_repeated\_eq} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prisoners\_repeated\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prisoners\_repeated\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{priv}}{priv}}\label{priv}

\texttt{priv} marks a field or method as private. Private members can
only be accessed from within the class.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Secret \{}
\NormalTok{    priv hidden: Int = 42}
\NormalTok{    priv fn internal \{ \}}
\NormalTok{    pub fn reveal \{ $self{-}\textgreater{}hidden \}  \# internal access ok}
\NormalTok{\}}
\NormalTok{\# $obj{-}\textgreater{}hidden  \# ERROR: field is private}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prm\_node\_connect}}{prm\_node\_connect}}\label{prm_node_connect}

\texttt{prm\_node\_connect} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prm\_node\_connect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prm\_node\_connect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{probability\_density}}{probability\_density}}\label{probability_density}

\texttt{probability\_density} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = probability\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map probability\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{probit\_log\_likelihood}}{probit\_log\_likelihood}}\label{probit_log_likelihood}

\texttt{probit\_log\_likelihood} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = probit\_log\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map probit\_log\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{proc\_mem}}{proc\_mem}}\label{proc_mem}

\texttt{proc\_mem} (alias \texttt{rss}) --- current process resident set
size (RSS) in bytes. On Linux reads \texttt{VmRSS} from
\texttt{/proc/self/status}. On macOS uses
\texttt{getrusage(RUSAGE\_SELF)}. Returns \texttt{undef} on unsupported
platforms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(rss)                      \# 18.5 MiB}
\NormalTok{my $before = rss}
\NormalTok{do\_work()}
\NormalTok{p format\_bytes(rss {-} $before) . " allocated"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{producer\_surplus}}{producer\_surplus}}\label{producer_surplus}

\texttt{producer\_surplus} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = producer\_surplus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map producer\_surplus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{product\_list}}{product\_list}}\label{product_list}

\texttt{product\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = product\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map product\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{product\_of}}{product\_of}}\label{product_of}

\texttt{product\_of} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = product\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map product\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{proj}}{proj}}\label{proj}

\texttt{proj} --- batch 11 builtin. Alias for \texttt{vector\_project}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = proj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map proj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{projectile\_max\_height}}{projectile\_max\_height}}\label{projectile_max_height}

\texttt{projectile\_max\_height(\$velocity,\ \$angle)} (alias
\texttt{projheight}) --- maximum height H = v²sin²(θ)/(2g).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p projheight(100, 45)   \# \textasciitilde{}255 m}
\NormalTok{p projheight(100, 90)   \# \textasciitilde{}510 m (straight up)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{projectile\_range}}{projectile\_range}}\label{projectile_range}

\texttt{projectile\_range(\$velocity,\ \$angle)} (alias
\texttt{projrange}) --- horizontal range R = v²sin(2θ)/g. Angle in
degrees.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p projrange(100, 45)   \# \textasciitilde{}1020 m (optimal angle for range)}
\NormalTok{p projrange(100, 30)   \# \textasciitilde{}884 m}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{projectile\_time}}{projectile\_time}}\label{projectile_time}

\texttt{projectile\_time} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = projectile\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map projectile\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{projtime}}{projtime}}\label{projtime}

\texttt{projtime} --- physics formulas builtin. Alias for
\texttt{projectile\_time}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = projtime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map projtime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pronic\_number}}{pronic\_number}}\label{pronic_number}

\texttt{pronic\_number} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pronic\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pronic\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prop\_table}}{prop\_table}}\label{prop_table}

\texttt{prop\_table} --- convert a count matrix to proportions (each
cell / total). Like R\textquotesingle s prop.table().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p prop\_table([[10,20],[30,40]])  \# [[0.1,0.2],[0.3,0.4]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prop\_test}}{prop\_test}}\label{prop_test}

\texttt{prop\_test} --- one-sample proportion z-test. Returns
{[}z-statistic, p-value{]}. Like R\textquotesingle s prop.test().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($z, $pval) = @\{proptest(55, 100, 0.5)\}  \# test if 55/100 differs from 50\%\%}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{proper\_motion\_apply}}{proper\_motion\_apply}}\label{proper_motion_apply}

\texttt{proper\_motion\_apply} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = proper\_motion\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map proper\_motion\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{proportional\_share}}{proportional\_share}}\label{proportional_share}

\texttt{proportional\_share} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = proportional\_share $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map proportional\_share |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{proton\_mass}}{proton\_mass}}\label{proton_mass}

\texttt{proton\_mass} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = proton\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map proton\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{proximal\_gradient\_step}}{proximal\_gradient\_step}}\label{proximal_gradient_step}

\texttt{proximal\_gradient\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = proximal\_gradient\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map proximal\_gradient\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{prvp}}{prvp}}\label{prvp}

\texttt{prvp} --- number theory / primes builtin. Alias for
\texttt{prev\_prime}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = prvp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map prvp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pseudoprime\_base2}}{pseudoprime\_base2}}\label{pseudoprime_base2}

\texttt{pseudoprime\_base2} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pseudoprime\_base2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pseudoprime\_base2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{psi\_to\_pascals}}{psi\_to\_pascals}}\label{psi_to_pascals}

\texttt{psi\_to\_pascals} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = psi\_to\_pascals $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pt}}{pt}}\label{pt}

\texttt{pt} --- Student\textquotesingle s t CDF. Args: x, df.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pt(1.96, 100)  \# ≈ 0.975}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ptdist}}{ptdist}}\label{ptdist}

\texttt{ptdist} --- geometry / physics builtin. Alias for
\texttt{point\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ptdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ptdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ptinpoly}}{ptinpoly}}\label{ptinpoly}

\texttt{ptinpoly} --- geometry (extended) builtin. Alias for
\texttt{point\_in\_polygon}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ptinpoly $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ptinpoly |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ptri}}{ptri}}\label{ptri}

\texttt{ptri} --- geometry / physics builtin. Alias for
\texttt{perimeter\_triangle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ptri $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ptri |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pttl}}{pttl}}\label{pttl}

\texttt{pttl} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pttl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pttl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pub}}{pub}}\label{pub}

\texttt{pub} marks a field or method as public (default visibility).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Example \{}
\NormalTok{    pub name: Str       \# explicitly public}
\NormalTok{    pub fn greet \{ \}    \# explicitly public}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{public\_goods\_game\_payoff}}{public\_goods\_game\_payoff}}\label{public_goods_game_payoff}

\texttt{public\_goods\_game\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = public\_goods\_game\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map public\_goods\_game\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pulse\_pressure}}{pulse\_pressure}}\label{pulse_pressure}

\texttt{pulse\_pressure} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pulse\_pressure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pulse\_pressure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{punct}}{punct}}\label{punct}

\texttt{punctuation} (alias \texttt{punct}) extracts all ASCII
punctuation characters from a string and returns them as a list. Filters
out letters, digits, whitespace --- keeps only punctuation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p join "", punctuation("Hello, world!")  \# ,!}
\NormalTok{"a.b{-}c" |\textgreater{} punct |\textgreater{} cnt |\textgreater{} p             \# 2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{punif}}{punif}}\label{punif}

\texttt{punif} --- uniform CDF. P(X ≤ x) for Uniform(a, b). Args: x, a,
b.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p punif(0.5, 0, 1)  \# 0.5}
\NormalTok{p punif(3, 0, 10)   \# 0.3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{punycode\_decode\_step}}{punycode\_decode\_step}}\label{punycode_decode_step}

\texttt{punycode\_decode\_step} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = punycode\_decode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map punycode\_decode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{punycode\_encode}}{punycode\_encode}}\label{punycode_encode}

\texttt{punycode\_encode} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = punycode\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map punycode\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pure\_state\_density}}{pure\_state\_density}}\label{pure_state_density}

\texttt{pure\_state\_density} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pure\_state\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pure\_state\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{purity}}{purity}}\label{purity}

\texttt{purity} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = purity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map purity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{purple}}{purple}}\label{purple}

\texttt{purple} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = purple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map purple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{push\_relabel\_relabel}}{push\_relabel\_relabel}}\label{push_relabel_relabel}

\texttt{push\_relabel\_relabel} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = push\_relabel\_relabel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map push\_relabel\_relabel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{push\_relabel\_step}}{push\_relabel\_step}}\label{push_relabel_step}

\texttt{push\_relabel\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = push\_relabel\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map push\_relabel\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pv}}{pv}}\label{pv}

\texttt{pv} --- finance (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pwave\_velocity\_depth}}{pwave\_velocity\_depth}}\label{pwave_velocity_depth}

\texttt{pwave\_velocity\_depth} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pwave\_velocity\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pwave\_velocity\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pwd\_str}}{pwd\_str}}\label{pwd_str}

\texttt{pwd\_str} --- more process / system builtin. Alias for
\texttt{cwd}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pwd\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pwd\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pweibull}}{pweibull}}\label{pweibull}

\texttt{pweibull} --- Weibull CDF. P(X ≤ x) for Weibull(shape, scale).
Args: x, shape, scale.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pweibull(1, 1, 1)  \# same as exponential}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pwi}}{pwi}}\label{pwi}

\texttt{pwi} --- python/ruby stdlib builtin. Alias for
\texttt{pairwise\_iter}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pwi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pwi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pwm\_score}}{pwm\_score}}\label{pwm_score}

\texttt{pwm\_score} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pwm\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pwm\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pyramid\_volume}}{pyramid\_volume}}\label{pyramid_volume}

\texttt{pyramid\_volume(\$base\_area,\ \$height)} --- computes the
volume of a pyramid. Returns \texttt{(1/3)\ *\ base\_area\ *\ height}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p pyramid\_volume(100, 15)   \# 500}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pyrvol}}{pyrvol}}\label{pyrvol}

\texttt{pyrvol} --- geometry (extended) builtin. Alias for
\texttt{pyramid\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pyrvol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pyrvol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pythagorean\_expectation}}{pythagorean\_expectation}}\label{pythagorean_expectation}

\texttt{pythagorean\_expectation} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pythagorean\_expectation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pythagorean\_expectation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pythagorean\_freq}}{pythagorean\_freq}}\label{pythagorean_freq}

\texttt{pythagorean\_freq} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pythagorean\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pythagorean\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{pythagorean\_ratio}}{pythagorean\_ratio}}\label{pythagorean_ratio}

\texttt{pythagorean\_ratio} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = pythagorean\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map pythagorean\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{q}}{q}}\label{q}

\texttt{q} --- quoting builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{q10}}{q10}}\label{q10}

\texttt{q10} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = q10 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map q10 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{q\_factor\_rlc}}{q\_factor\_rlc}}\label{q_factor_rlc}

\texttt{q\_factor\_rlc} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = q\_factor\_rlc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map q\_factor\_rlc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{q\_learning\_update}}{q\_learning\_update}}\label{q_learning_update}

\texttt{q\_learning\_update} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = q\_learning\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map q\_learning\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qaly\_lifetime}}{qaly\_lifetime}}\label{qaly_lifetime}

\texttt{qaly\_lifetime} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qaly\_lifetime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qaly\_lifetime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qaoa\_step}}{qaoa\_step}}\label{qaoa_step}

\texttt{qaoa\_step} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qaoa\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qaoa\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qap\_lower\_bound}}{qap\_lower\_bound}}\label{qap_lower_bound}

\texttt{qap\_lower\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qap\_lower\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qap\_lower\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qbeta}}{qbeta}}\label{qbeta}

\texttt{qbeta} --- beta quantile. Args: p, alpha, beta.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qbeta(0.5, 2, 5)  \# median of Beta(2,5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qbinom}}{qbinom}}\label{qbinom}

\texttt{qbinom} --- binomial quantile (smallest k where P(X≤k) ≥ p).
Args: p, n, prob.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qbinom(0.5, 10, 0.5)  \# median of Binom(10, 0.5) = 5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qbo\_oscillation\_step}}{qbo\_oscillation\_step}}\label{qbo_oscillation_step}

\texttt{qbo\_oscillation\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qbo\_oscillation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qbo\_oscillation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qbr\_metric}}{qbr\_metric}}\label{qbr_metric}

\texttt{qbr\_metric} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qbr\_metric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qbr\_metric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qcauchy}}{qcauchy}}\label{qcauchy}

\texttt{qcauchy} --- Cauchy quantile. Args: p {[}, location, scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qcauchy(0.75, 0, 1)  \# 1.0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qchisq}}{qchisq}}\label{qchisq}

\texttt{qchisq} --- chi-squared quantile. Args: p, df.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qchisq(0.95, 1)  \# 3.84 (critical value)}
\NormalTok{p qchisq(0.95, 5)  \# 11.07}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qdisc}}{qdisc}}\label{qdisc}

\texttt{quadratic\_discriminant(\$a,\ \$b,\ \$c)} (alias \texttt{qdisc})
--- computes b² - 4ac. Positive = two real roots, zero = one repeated
root, negative = complex roots.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qdisc(1, {-}5, 6)   \# 1 (two distinct real roots)}
\NormalTok{p qdisc(1, 2, 1)    \# 0 (one repeated root)}
\NormalTok{p qdisc(1, 2, 5)    \# {-}16 (complex roots)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qexp}}{qexp}}\label{qexp}

\texttt{qexp} --- exponential quantile. Args: p {[}, rate{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qexp(0.5, 1)       \# 0.693 (median of Exp(1))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qf}}{qf}}\label{qf}

\texttt{qf} --- F-distribution quantile. Args: p, d1, d2.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qf(0.95, 5, 10)  \# critical F value}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qft}}{qft}}\label{qft}

\texttt{qft} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qft $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qft |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qft\_4\_real}}{qft\_4\_real}}\label{qft_4_real}

\texttt{qft\_4\_real} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qft\_4\_real $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qft\_4\_real |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qgamma}}{qgamma}}\label{qgamma}

\texttt{qgamma} --- gamma quantile (inverse CDF). Args: p, shape {[},
scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qgamma(0.95, 2, 1)  \# 95th percentile of Gamma(2,1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qho\_ground\_state}}{qho\_ground\_state}}\label{qho_ground_state}

\texttt{qho\_ground\_state} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qho\_ground\_state $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qho\_ground\_state |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qlnorm}}{qlnorm}}\label{qlnorm}

\texttt{qlnorm} --- log-normal quantile. Args: p {[}, mu, sigma{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qlnorm(0.5, 0, 1)  \# 1.0 (median of LogN(0,1))}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qm}}{qm}}\label{qm}

\texttt{qm} --- string builtin. Alias for \texttt{quotemeta}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qnorm}}{qnorm}}\label{qnorm}

\texttt{qnorm} --- normal quantile (inverse CDF). Returns x such that
P(X ≤ x) = p. Args: p {[}, mu, sigma{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qnorm(0.975)      \# 1.96}
\NormalTok{p qnorm(0.5)        \# 0.0}
\NormalTok{p qnorm(0.95, 100, 15)  \# 90th percentile IQ}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qntl}}{qntl}}\label{qntl}

\texttt{qntl} --- extended stdlib builtin. Alias for \texttt{quantile}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qntl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qntl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qntls}}{qntls}}\label{qntls}

\texttt{quantiles\ \textbackslash{}@DATA,\ \textbackslash{}@PROBS} ---
batch quantile lookup. Returns one element per probability in
\texttt{\textbackslash{}@PROBS}, computed via the same linear
interpolation as \texttt{quantile}. Sorts the data exactly once across
all probability points so callers don\textquotesingle t pay an O(n log
n) sort per quantile. Probabilities outside {[}0,1{]} are clamped.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @d = (1..1000)}
\NormalTok{my @qs = quantiles(\textbackslash{}@d, [0.25, 0.5, 0.75])}
\NormalTok{printf "q25=\%.2f q50=\%.2f q75=\%.2f\textbackslash{}n", @qs}
\NormalTok{\# q25=250.75 q50=500.50 q75=750.25}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qpe\_iteration}}{qpe\_iteration}}\label{qpe_iteration}

\texttt{qpe\_iteration} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qpe\_iteration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qpe\_iteration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qpois}}{qpois}}\label{qpois}

\texttt{qpois} --- Poisson quantile (smallest k where P(X≤k) ≥ p). Args:
p, lambda.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qpois(0.5, 5)  \# median of Poisson(5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qq}}{qq}}\label{qq}

\texttt{qq} --- quoting builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qroots}}{qroots}}\label{qroots}

\texttt{quadratic\_roots(\$a,\ \$b,\ \$c)} (alias \texttt{qroots}) ---
solves ax² + bx + c = 0. Returns {[}x1, x2{]} for real roots, undef if
no real solutions (discriminant \textless{} 0).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @roots = quadratic\_roots(1, {-}5, 6)  \# [3, 2] (x² {-} 5x + 6 = 0)}
\NormalTok{p qroots(1, 0, {-}4)                      \# [2, {-}2]}
\NormalTok{p qroots(1, 2, 5)                       \# undef (complex roots)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qs\_relation}}{qs\_relation}}\label{qs_relation}

\texttt{qs\_relation} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qs\_relation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qs\_relation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qt}}{qt}}\label{qt}

\texttt{qt} --- Student\textquotesingle s t quantile. Args: p, df.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qt(0.975, 10)   \# ≈ 2.228 (two{-}tailed 5\%)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quadratic\_assignment\_step}}{quadratic\_assignment\_step}}\label{quadratic_assignment_step}

\texttt{quadratic\_assignment\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quadratic\_assignment\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quadratic\_assignment\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quadratic\_mean\_arr}}{quadratic\_mean\_arr}}\label{quadratic_mean_arr}

\texttt{quadratic\_mean\_arr} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quadratic\_mean\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quadratic\_mean\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantal\_response\_logit}}{quantal\_response\_logit}}\label{quantal_response_logit}

\texttt{quantal\_response\_logit} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantal\_response\_logit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantal\_response\_logit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantile}}{quantile}}\label{quantile}

\texttt{quantile} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantile\_p}}{quantile\_p}}\label{quantile_p}

\texttt{quantile\_p} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantile\_p $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantile\_p |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantize}}{quantize}}\label{quantize}

\texttt{quantize} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quanto\_adjustment}}{quanto\_adjustment}}\label{quanto_adjustment}

\texttt{quanto\_adjustment} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quanto\_adjustment $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_dimension\_q}}{quantum\_dimension\_q}}\label{quantum_dimension_q}

\texttt{quantum\_dimension\_q} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_dimension\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_dimension\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_dimension\_su2}}{quantum\_dimension\_su2}}\label{quantum_dimension_su2}

\texttt{quantum\_dimension\_su2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_dimension\_su2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_dimension\_su2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_efficiency\_photo}}{quantum\_efficiency\_photo}}\label{quantum_efficiency_photo}

\texttt{quantum\_efficiency\_photo} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_efficiency\_photo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_efficiency\_photo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_fidelity\_pure}}{quantum\_fidelity\_pure}}\label{quantum_fidelity_pure}

\texttt{quantum\_fidelity\_pure} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_fidelity\_pure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_fidelity\_pure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_fisher\_info}}{quantum\_fisher\_info}}\label{quantum_fisher_info}

\texttt{quantum\_fisher\_info} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_fisher\_info $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_fisher\_info |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_invariant\_eval}}{quantum\_invariant\_eval}}\label{quantum_invariant_eval}

\texttt{quantum\_invariant\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_invariant\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_invariant\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_mutual\_info}}{quantum\_mutual\_info}}\label{quantum_mutual_info}

\texttt{quantum\_mutual\_info} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_mutual\_info $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_mutual\_info |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_relative\_entropy}}{quantum\_relative\_entropy}}\label{quantum_relative_entropy}

\texttt{quantum\_relative\_entropy} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_relative\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_relative\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_teleportation}}{quantum\_teleportation}}\label{quantum_teleportation}

\texttt{quantum\_teleportation} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_teleportation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_teleportation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quantum\_variance}}{quantum\_variance}}\label{quantum_variance}

\texttt{quantum\_variance} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quantum\_variance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quantum\_variance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quarter\_of}}{quarter\_of}}\label{quarter_of}

\texttt{quarter\_of} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quarter\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quarter\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quarter\_of\_year}}{quarter\_of\_year}}\label{quarter_of_year}

\texttt{quarter\_of\_year} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quarter\_of\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quarter\_of\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quartile\_exc}}{quartile\_exc}}\label{quartile_exc}

\texttt{quartile\_exc} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quartile\_exc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quartile\_exc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quartile\_inc}}{quartile\_inc}}\label{quartile_inc}

\texttt{quartile\_inc} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quartile\_inc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quartile\_inc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quartiles}}{quartiles}}\label{quartiles}

\texttt{quartiles(@data)} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @data = 1:100}
\NormalTok{my $q = quartiles(@data)}
\NormalTok{p "Q1=$q{-}\textgreater{}[0] Q2=$q{-}\textgreater{}[1] Q3=$q{-}\textgreater{}[2]"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quarts}}{quarts}}\label{quarts}

\texttt{quarts} --- statistics (extended) builtin. Alias for
\texttt{quartiles}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quarts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quarts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quasi\_geostrophic\_omega}}{quasi\_geostrophic\_omega}}\label{quasi_geostrophic_omega}

\texttt{quasi\_geostrophic\_omega} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quasi\_geostrophic\_omega $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quasi\_geostrophic\_omega |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quaternion\_from\_imu}}{quaternion\_from\_imu}}\label{quaternion_from_imu}

\texttt{quaternion\_from\_imu} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quaternion\_from\_imu $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quaternion\_from\_imu |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_ccx}}{qubit\_ccx}}\label{qubit_ccx}

\texttt{qubit\_ccx} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_ccx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_ccx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_cnot}}{qubit\_cnot}}\label{qubit_cnot}

\texttt{qubit\_cnot} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_cnot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_cnot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_cz}}{qubit\_cz}}\label{qubit_cz}

\texttt{qubit\_cz} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_cz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_cz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_h}}{qubit\_h}}\label{qubit_h}

\texttt{qubit\_h} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_h $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_h |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_measure}}{qubit\_measure}}\label{qubit_measure}

\texttt{qubit\_measure} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_measure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_measure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_phase}}{qubit\_phase}}\label{qubit_phase}

\texttt{qubit\_phase} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_phase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_phase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_reset}}{qubit\_reset}}\label{qubit_reset}

\texttt{qubit\_reset} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_reset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_reset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_rx}}{qubit\_rx}}\label{qubit_rx}

\texttt{qubit\_rx} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_rx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_rx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_ry}}{qubit\_ry}}\label{qubit_ry}

\texttt{qubit\_ry} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_ry $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_ry |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_rz}}{qubit\_rz}}\label{qubit_rz}

\texttt{qubit\_rz} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_rz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_rz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_s}}{qubit\_s}}\label{qubit_s}

\texttt{qubit\_s} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_s $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_s |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_swap}}{qubit\_swap}}\label{qubit_swap}

\texttt{qubit\_swap} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_swap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_swap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_t}}{qubit\_t}}\label{qubit_t}

\texttt{qubit\_t} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_u1}}{qubit\_u1}}\label{qubit_u1}

\texttt{qubit\_u1} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_u1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_u1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_u2}}{qubit\_u2}}\label{qubit_u2}

\texttt{qubit\_u2} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_u2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_u2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_u3}}{qubit\_u3}}\label{qubit_u3}

\texttt{qubit\_u3} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_u3 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_u3 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_x}}{qubit\_x}}\label{qubit_x}

\texttt{qubit\_x} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_x $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_x |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_y}}{qubit\_y}}\label{qubit_y}

\texttt{qubit\_y} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_y $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_y |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qubit\_z}}{qubit\_z}}\label{qubit_z}

\texttt{qubit\_z} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qubit\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qubit\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{queue\_new}}{queue\_new}}\label{queue_new}

\texttt{queue\_new} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = queue\_new $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map queue\_new |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quiver\_path\_count}}{quiver\_path\_count}}\label{quiver_path_count}

\texttt{quiver\_path\_count} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quiver\_path\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quiver\_path\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qunif}}{qunif}}\label{qunif}

\texttt{qunif} --- uniform quantile. Args: p {[}, min, max{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qunif(0.5, 0, 10)  \# 5.0 (median)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quote}}{quote}}\label{quote}

\texttt{quote} --- string quote / escape builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quote $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quote |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{quoted\_printable\_encode}}{quoted\_printable\_encode}}\label{quoted_printable_encode}

\texttt{quoted\_printable\_encode} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = quoted\_printable\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map quoted\_printable\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qw}}{qw}}\label{qw}

\texttt{qw} --- quoting builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = qw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map qw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{qweibull}}{qweibull}}\label{qweibull}

\texttt{qweibull} --- Weibull quantile. Args: p, shape {[}, scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p qweibull(0.5, 1, 1)  \# same as qexp}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r0\_basic}}{r0\_basic}}\label{r0_basic}

\texttt{r0\_basic} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r0\_basic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r0\_basic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r2d}}{r2d}}\label{r2d}

\texttt{r2d} --- trivial numeric / predicate builtins builtin. Alias for
\texttt{rad\_to\_deg}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r2d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r2d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r72}}{r72}}\label{r72}

\texttt{rule\_of\_72(\$rate)} (alias \texttt{r72}) --- estimates years
to double investment using the Rule of 72: 72 / (rate × 100). Quick
mental math approximation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p r72(0.06)   \# 12 years to double at 6\%}
\NormalTok{p r72(0.10)   \# 7.2 years at 10\%}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r\_effective\_t}}{r\_effective\_t}}\label{r_effective_t}

\texttt{r\_effective\_t} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r\_effective\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r\_effective\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r\_naught\_basic}}{r\_naught\_basic}}\label{r_naught_basic}

\texttt{r\_naught\_basic} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r\_naught\_basic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r\_naught\_basic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r\_parallel}}{r\_parallel}}\label{r_parallel}

\texttt{r\_parallel} --- batch 12 builtin. Alias for
\texttt{resistance\_parallel}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r\_parallel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r\_parallel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r\_series}}{r\_series}}\label{r_series}

\texttt{r\_series} --- batch 12 builtin. Alias for
\texttt{resistance\_series}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r\_series $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r\_series |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{r\_squared}}{r\_squared}}\label{r_squared}

\texttt{r\_squared} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = r\_squared $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map r\_squared |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ra\_dec\_to\_alt\_az}}{ra\_dec\_to\_alt\_az}}\label{ra_dec_to_alt_az}

\texttt{ra\_dec\_to\_alt\_az} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ra\_dec\_to\_alt\_az $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ra\_dec\_to\_az\_alt}}{ra\_dec\_to\_az\_alt}}\label{ra_dec_to_az_alt}

\texttt{ra\_dec\_to\_az\_alt} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ra\_dec\_to\_az\_alt $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rabi\_frequency}}{rabi\_frequency}}\label{rabi_frequency}

\texttt{rabi\_frequency} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rabi\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rabi\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rabin\_karp\_hash}}{rabin\_karp\_hash}}\label{rabin_karp_hash}

\texttt{rabin\_karp\_hash} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rabin\_karp\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rabin\_karp\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rad\_to\_deg}}{rad\_to\_deg}}\label{rad_to_deg}

\texttt{rad\_to\_deg} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rad\_to\_deg $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{radd}}{radd}}\label{radd}

\texttt{radd} --- roman numerals builtin. Alias for \texttt{roman\_add}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = radd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map radd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{radians}}{radians}}\label{radians}

\texttt{radians} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = radians $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map radians |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{radiation\_pressure}}{radiation\_pressure}}\label{radiation_pressure}

\texttt{radiation\_pressure} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = radiation\_pressure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map radiation\_pressure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{radius\_bfs}}{radius\_bfs}}\label{radius_bfs}

\texttt{radius\_bfs} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = radius\_bfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map radius\_bfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ragone\_point}}{ragone\_point}}\label{ragone_point}

\texttt{ragone\_point} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ragone\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ragone\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{railfence\_encrypt}}{railfence\_encrypt}}\label{railfence_encrypt}

\texttt{railfence\_encrypt} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = railfence\_encrypt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map railfence\_encrypt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ramachandran\_phi\_psi}}{ramachandran\_phi\_psi}}\label{ramachandran_phi_psi}

\texttt{ramachandran\_phi\_psi} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ramachandran\_phi\_psi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ramachandran\_phi\_psi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ramsey\_reset\_test}}{ramsey\_reset\_test}}\label{ramsey_reset_test}

\texttt{ramsey\_reset\_test} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ramsey\_reset\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ramsey\_reset\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ramsey\_visibility}}{ramsey\_visibility}}\label{ramsey_visibility}

\texttt{ramsey\_visibility} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ramsey\_visibility $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ramsey\_visibility |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{randles\_circuit\_z}}{randles\_circuit\_z}}\label{randles_circuit_z}

\texttt{randles\_circuit\_z} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = randles\_circuit\_z $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map randles\_circuit\_z |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{randles\_sevcik\_peak}}{randles\_sevcik\_peak}}\label{randles_sevcik_peak}

\texttt{randles\_sevcik\_peak} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = randles\_sevcik\_peak $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map randles\_sevcik\_peak |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_alpha}}{random\_alpha}}\label{random_alpha}

\texttt{random\_alpha} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_alpha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_alpha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_between}}{random\_between}}\label{random_between}

\texttt{random\_between} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_bool}}{random\_bool}}\label{random_bool}

\texttt{random\_bool} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_bool $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_bool |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_char}}{random\_char}}\label{random_char}

\texttt{random\_char} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_char $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_char |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_choice}}{random\_choice}}\label{random_choice}

\texttt{random\_choice} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_choice $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_choice |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_color}}{random\_color}}\label{random_color}

\texttt{random\_color} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_color $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_color |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_digit}}{random\_digit}}\label{random_digit}

\texttt{random\_digit} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_digit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_digit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_float}}{random\_float}}\label{random_float}

\texttt{random\_float} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_float $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_float |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_int}}{random\_int}}\label{random_int}

\texttt{random\_int} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_int $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_int |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_sample}}{random\_sample}}\label{random_sample}

\texttt{random\_sample} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_sample $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_sample |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_string}}{random\_string}}\label{random_string}

\texttt{random\_string} --- random builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_walk\_drift\_step}}{random\_walk\_drift\_step}}\label{random_walk_drift_step}

\texttt{random\_walk\_drift\_step} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_walk\_drift\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_walk\_drift\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_walk\_hitting}}{random\_walk\_hitting}}\label{random_walk_hitting}

\texttt{random\_walk\_hitting} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_walk\_hitting $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_walk\_hitting |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{random\_walk\_innovation}}{random\_walk\_innovation}}\label{random_walk_innovation}

\texttt{random\_walk\_innovation} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = random\_walk\_innovation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map random\_walk\_innovation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_coding\_step}}{range\_coding\_step}}\label{range_coding_step}

\texttt{range\_coding\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_coding\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_coding\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_compress}}{range\_compress}}\label{range_compress}

\texttt{range\_compress} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_compress $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_compress |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_decode\_step}}{range\_decode\_step}}\label{range_decode_step}

\texttt{range\_decode\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_decode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_decode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_exclusive}}{range\_exclusive}}\label{range_exclusive}

\texttt{range\_exclusive} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_exclusive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_exclusive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_expand}}{range\_expand}}\label{range_expand}

\texttt{range\_expand} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_expand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_expand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_header\_parse}}{range\_header\_parse}}\label{range_header_parse}

\texttt{range\_header\_parse} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_header\_parse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_header\_parse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_inclusive}}{range\_inclusive}}\label{range_inclusive}

\texttt{range\_inclusive} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_inclusive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_inclusive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_of}}{range\_of}}\label{range_of}

\texttt{range\_of} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{range\_voting\_score}}{range\_voting\_score}}\label{range_voting_score}

\texttt{range\_voting\_score} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = range\_voting\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map range\_voting\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rank}}{rank}}\label{rank}

\texttt{rank} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rank\_avg}}{rank\_avg}}\label{rank_avg}

\texttt{rank\_avg} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rank\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rank\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rank\_eq}}{rank\_eq}}\label{rank_eq}

\texttt{rank\_eq} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rank\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rank\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ransac\_homography}}{ransac\_homography}}\label{ransac_homography}

\texttt{ransac\_homography} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ransac\_homography $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ransac\_homography |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ransac\_iteration\_count}}{ransac\_iteration\_count}}\label{ransac_iteration_count}

\texttt{ransac\_iteration\_count} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ransac\_iteration\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ransac\_iteration\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rao\_quadratic\_entropy}}{rao\_quadratic\_entropy}}\label{rao_quadratic_entropy}

\texttt{rao\_quadratic\_entropy} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rao\_quadratic\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rao\_quadratic\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{raoult\_law}}{raoult\_law}}\label{raoult_law}

\texttt{raoult\_law} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = raoult\_law $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map raoult\_law |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rapid\_blink}}{rapid\_blink}}\label{rapid_blink}

\texttt{rapid\_blink} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rapid\_blink $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rapid\_blink |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rate}}{rate}}\label{rate}

\texttt{rate} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{raychaudhuri\_step}}{raychaudhuri\_step}}\label{raychaudhuri_step}

\texttt{raychaudhuri\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = raychaudhuri\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map raychaudhuri\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rayleigh\_criterion}}{rayleigh\_criterion}}\label{rayleigh_criterion}

\texttt{rayleigh\_criterion} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rayleigh\_criterion $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rayleigh\_criterion |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rayleigh\_number\_step}}{rayleigh\_number\_step}}\label{rayleigh_number_step}

\texttt{rayleigh\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rayleigh\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rayleigh\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rayleigh\_resolution}}{rayleigh\_resolution}}\label{rayleigh_resolution}

\texttt{rayleigh\_resolution} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rayleigh\_resolution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rayleigh\_resolution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rb}}{rb}}\label{rb}

\texttt{rb} --- filesystem extensions builtin. Alias for
\texttt{read\_bytes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rbeta}}{rbeta}}\label{rbeta}

\texttt{rbeta} --- generate n random beta variates. Args: n, alpha,
beta. Like R\textquotesingle s rbeta().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rbeta(100, 2, 5)\}     \# Beta(2,5)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rbind}}{rbind}}\label{rbind}

\texttt{rbind} --- bind matrices/vectors by rows (vertical stack). Like
R\textquotesingle s rbind().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $m = rbind([1,2,3], [4,5,6])  \# [[1,2,3],[4,5,6]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rbinom}}{rbinom}}\label{rbinom}

\texttt{rbinom} --- generate n random binomial variates. Args: n, size,
prob. Like R\textquotesingle s rbinom().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rbinom(100, 10, 0.3)\} \# 100 draws from Binom(10,0.3)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rc\_tau}}{rc\_tau}}\label{rc_tau}

\texttt{rc\_tau} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rc\_tau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rc\_tau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rc\_time\_constant}}{rc\_time\_constant}}\label{rc_time_constant}

\texttt{rc\_time\_constant} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rc\_time\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rc\_time\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rcauchy}}{rcauchy}}\label{rcauchy}

\texttt{rcauchy} --- generate n random Cauchy variates. Args: n {[},
location, scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rcauchy(100, 0, 1)\}   \# standard Cauchy}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rchisq}}{rchisq}}\label{rchisq}

\texttt{rchisq} --- generate n random chi-squared variates. Args: n, df.
Like R\textquotesingle s rchisq().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rchisq(100, 5)\}       \# Chi{-}sq with 5 df}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rcolor}}{rcolor}}\label{rcolor}

\texttt{rcolor} --- color operations builtin. Alias for
\texttt{random\_color}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rcolor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rcolor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rctau}}{rctau}}\label{rctau}

\texttt{rctau} --- physics formulas builtin. Alias for
\texttt{rc\_time\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rctau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rctau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rdcs}}{rdcs}}\label{rdcs}

\texttt{rdcs} --- algebraic match builtin. Alias for
\texttt{reductions}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rdcs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rdcs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rdd\_estimate}}{rdd\_estimate}}\label{rdd_estimate}

\texttt{rdd\_estimate} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rdd\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rdd\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{re\_escape}}{re\_escape}}\label{re_escape}

\texttt{re\_escape} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = re\_escape $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map re\_escape |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{re\_find\_all}}{re\_find\_all}}\label{re_find_all}

\texttt{re\_find\_all} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = re\_find\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map re\_find\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{re\_groups}}{re\_groups}}\label{re_groups}

\texttt{re\_groups} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = re\_groups $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map re\_groups |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{re\_match}}{re\_match}}\label{re_match}

\texttt{re\_match} --- file stat / path builtin. Alias for
\texttt{matches\_regex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = re\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map re\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{re\_split\_limit}}{re\_split\_limit}}\label{re_split_limit}

\texttt{re\_split\_limit} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = re\_split\_limit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map re\_split\_limit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{re\_test}}{re\_test}}\label{re_test}

\texttt{re\_test} --- more regex builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = re\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map re\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reaction\_quotient}}{reaction\_quotient}}\label{reaction_quotient}

\texttt{reaction\_quotient} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reaction\_quotient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reaction\_quotient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{realized\_volatility}}{realized\_volatility}}\label{realized_volatility}

\texttt{realized\_volatility} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = realized\_volatility $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map realized\_volatility |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rearth}}{rearth}}\label{rearth}

\texttt{rearth} --- physics constants builtin. Alias for
\texttt{earth\_radius}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rearth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rearth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{received}}{received}}\label{received}

\texttt{received} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = received $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map received |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{recip}}{recip}}\label{recip}

\texttt{recip} --- extended stdlib builtin. Alias for
\texttt{reciprocal\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = recip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map recip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reciprocal}}{reciprocal}}\label{reciprocal}

\texttt{reciprocal} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reciprocal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reciprocal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reciprocal\_of}}{reciprocal\_of}}\label{reciprocal_of}

\texttt{reciprocal\_of} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reciprocal\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reciprocal\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reciprocal\_pdf}}{reciprocal\_pdf}}\label{reciprocal_pdf}

\texttt{reciprocal\_pdf} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reciprocal\_pdf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reciprocal\_pdf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{red}}{red}}\label{red}

\texttt{red} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = red $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map red |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{red\_bold}}{red\_bold}}\label{red_bold}

\texttt{red\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = red\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map red\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{redi}}{redi}}\label{redi}

\texttt{redi} --- go/general functional utilities builtin. Alias for
\texttt{reduce\_indexed}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = redi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map redi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{redlich\_kwong\_p}}{redlich\_kwong\_p}}\label{redlich_kwong_p}

\texttt{redlich\_kwong\_p} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = redlich\_kwong\_p $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map redlich\_kwong\_p |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{redox\_potential\_cell}}{redox\_potential\_cell}}\label{redox_potential_cell}

\texttt{redox\_potential\_cell} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = redox\_potential\_cell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map redox\_potential\_cell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{redr}}{redr}}\label{redr}

\texttt{redr} --- additional missing stdlib functions builtin. Alias for
\texttt{reduce\_right}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = redr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map redr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{redshift\_from\_a}}{redshift\_from\_a}}\label{redshift_from_a}

\texttt{redshift\_from\_a} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = redshift\_from\_a $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map redshift\_from\_a |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reduce\_axis}}{reduce\_axis}}\label{reduce_axis}

\texttt{reduce\_axis} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reduce\_axis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reduce\_axis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reduce\_indexed}}{reduce\_indexed}}\label{reduce_indexed}

\texttt{reduce\_indexed} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reduce\_indexed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reduce\_indexed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reduce\_right}}{reduce\_right}}\label{reduce_right}

\texttt{reduce\_right} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reduce\_right $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reduce\_right |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{refaddr}}{refaddr}}\label{refaddr}

\texttt{refaddr} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = refaddr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map refaddr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{refl\_check}}{refl\_check}}\label{refl_check}

\texttt{refl\_check} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = refl\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map refl\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reflect\_point}}{reflect\_point}}\label{reflect_point}

\texttt{reflect\_point(\$x,\ \$y,\ \$axis)} --- reflects a point across
an axis. Axis can be \textquotesingle x\textquotesingle,
\textquotesingle y\textquotesingle, or
\textquotesingle origin\textquotesingle. Returns the reflected
coordinates.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p reflect\_point(3, 4, \textquotesingle{}x\textquotesingle{})       \# [3, {-}4]}
\NormalTok{p reflect\_point(3, 4, \textquotesingle{}y\textquotesingle{})       \# [{-}3, 4]}
\NormalTok{p reflect\_point(3, 4, \textquotesingle{}origin\textquotesingle{})  \# [{-}3, {-}4]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reflpt}}{reflpt}}\label{reflpt}

\texttt{reflpt} --- geometry (extended) builtin. Alias for
\texttt{reflect\_point}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reflpt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reflpt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{refresh\_stashes}}{refresh\_stashes}}\label{refresh_stashes}

\texttt{refresh\_stashes} --- symbol table builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = refresh\_stashes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map refresh\_stashes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reftype}}{reftype}}\label{reftype}

\texttt{reftype} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reftype $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reftype |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_compile\_thompson}}{regex\_compile\_thompson}}\label{regex_compile_thompson}

\texttt{regex\_compile\_thompson} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_compile\_thompson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regex\_compile\_thompson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_escape\_simple}}{regex\_escape\_simple}}\label{regex_escape_simple}

\texttt{regex\_escape\_simple} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_escape\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regex\_escape\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_extract}}{regex\_extract}}\label{regex_extract}

\texttt{regex\_extract} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_extract $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regex\_extract |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_match\_dfa}}{regex\_match\_dfa}}\label{regex_match_dfa}

\texttt{regex\_match\_dfa} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_match\_dfa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regex\_match\_dfa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_replace\_str}}{regex\_replace\_str}}\label{regex_replace_str}

\texttt{regex\_replace\_str} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_replace\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regex\_replace\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_split\_str}}{regex\_split\_str}}\label{regex_split_str}

\texttt{regex\_split\_str} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_split\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regex\_split\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regex\_to\_nfa\_thompson}}{regex\_to\_nfa\_thompson}}\label{regex_to_nfa_thompson}

\texttt{regex\_to\_nfa\_thompson} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regex\_to\_nfa\_thompson $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regexp\_matches}}{regexp\_matches}}\label{regexp_matches}

\texttt{regexp\_matches} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regexp\_matches $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regexp\_matches |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regexp\_replace}}{regexp\_replace}}\label{regexp_replace}

\texttt{regexp\_replace} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regexp\_replace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regexp\_replace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regexp\_split}}{regexp\_split}}\label{regexp_split}

\texttt{regexp\_split} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regexp\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regexp\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regr\_intercept}}{regr\_intercept}}\label{regr_intercept}

\texttt{regr\_intercept} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regr\_intercept $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regr\_intercept |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regr\_r2}}{regr\_r2}}\label{regr_r2}

\texttt{regr\_r2} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regr\_r2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regr\_r2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regr\_slope}}{regr\_slope}}\label{regr_slope}

\texttt{regr\_slope} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regr\_slope $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regr\_slope |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regula\_falsi}}{regula\_falsi}}\label{regula_falsi}

\texttt{regula\_falsi} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regula\_falsi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regula\_falsi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regular\_ngon\_area}}{regular\_ngon\_area}}\label{regular_ngon_area}

\texttt{regular\_ngon\_area} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regular\_ngon\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regular\_ngon\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regular\_ngon\_circumradius}}{regular\_ngon\_circumradius}}\label{regular_ngon_circumradius}

\texttt{regular\_ngon\_circumradius} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regular\_ngon\_circumradius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regular\_ngon\_circumradius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regular\_ngon\_inradius}}{regular\_ngon\_inradius}}\label{regular_ngon_inradius}

\texttt{regular\_ngon\_inradius} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regular\_ngon\_inradius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regular\_ngon\_inradius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{regulator\_naive}}{regulator\_naive}}\label{regulator_naive}

\texttt{regulator\_naive} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = regulator\_naive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map regulator\_naive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reject\_if}}{reject\_if}}\label{reject_if}

\texttt{reject\_if} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reject\_if $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reject\_if |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rel\_energy\_pm}}{rel\_energy\_pm}}\label{rel_energy_pm}

\texttt{rel\_energy\_pm} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rel\_energy\_pm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rel\_energy\_pm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rel\_ke}}{rel\_ke}}\label{rel_ke}

\texttt{rel\_ke} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rel\_ke $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rel\_ke |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rel\_momentum}}{rel\_momentum}}\label{rel_momentum}

\texttt{rel\_momentum} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rel\_momentum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rel\_momentum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rel\_total\_energy}}{rel\_total\_energy}}\label{rel_total_energy}

\texttt{rel\_total\_energy} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rel\_total\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rel\_total\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rel\_velocity\_add}}{rel\_velocity\_add}}\label{rel_velocity_add}

\texttt{rel\_velocity\_add} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rel\_velocity\_add $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rel\_velocity\_add |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relative\_entropy\_coherence}}{relative\_entropy\_coherence}}\label{relative_entropy_coherence}

\texttt{relative\_entropy\_coherence} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relative\_entropy\_coherence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relative\_entropy\_coherence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relative\_entropy\_kl}}{relative\_entropy\_kl}}\label{relative_entropy_kl}

\texttt{relative\_entropy\_kl} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relative\_entropy\_kl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relative\_entropy\_kl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relative\_humidity\_step}}{relative\_humidity\_step}}\label{relative_humidity_step}

\texttt{relative\_humidity\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relative\_humidity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relative\_humidity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relative\_luminance}}{relative\_luminance}}\label{relative_luminance}

\texttt{relative\_luminance} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relative\_luminance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relative\_luminance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relative\_vorticity\_step}}{relative\_vorticity\_step}}\label{relative_vorticity_step}

\texttt{relative\_vorticity\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relative\_vorticity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relative\_vorticity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relativistic\_doppler}}{relativistic\_doppler}}\label{relativistic_doppler}

\texttt{relativistic\_doppler} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relativistic\_doppler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relativistic\_doppler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relativistic\_energy}}{relativistic\_energy}}\label{relativistic_energy}

\texttt{relativistic\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relativistic\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relativistic\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relativistic\_kinetic}}{relativistic\_kinetic}}\label{relativistic_kinetic}

\texttt{relativistic\_kinetic} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relativistic\_kinetic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relativistic\_kinetic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relativistic\_mass}}{relativistic\_mass}}\label{relativistic_mass}

\texttt{relativistic\_mass} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relativistic\_mass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relativistic\_mass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relenergy}}{relenergy}}\label{relenergy}

\texttt{relenergy} --- physics formulas builtin. Alias for
\texttt{relativistic\_energy}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relenergy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relenergy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reliability\_diagram}}{reliability\_diagram}}\label{reliability_diagram}

\texttt{reliability\_diagram} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reliability\_diagram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reliability\_diagram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relmass}}{relmass}}\label{relmass}

\texttt{relmass} --- physics formulas builtin. Alias for
\texttt{relativistic\_mass}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relmass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relmass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relu}}{relu}}\label{relu}

\texttt{relu} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relu $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relu |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{relu\_grad}}{relu\_grad}}\label{relu_grad}

\texttt{relu\_grad} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = relu\_grad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map relu\_grad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remc}}{remc}}\label{remc}

\texttt{remc} --- algebraic match builtin. Alias for
\texttt{remove\_clj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remez\_design}}{remez\_design}}\label{remez_design}

\texttt{remez\_design} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remez\_design $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remez\_design |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_all\_str}}{remove\_all\_str}}\label{remove_all_str}

\texttt{remove\_all\_str} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_all\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_all\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_at}}{remove\_at}}\label{remove_at}

\texttt{remove\_at} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_clj}}{remove\_clj}}\label{remove_clj}

\texttt{remove\_clj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_clj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_clj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_consonants}}{remove\_consonants}}\label{remove_consonants}

\texttt{remove\_consonants} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_consonants $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_consonants |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_elem}}{remove\_elem}}\label{remove_elem}

\texttt{remove\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_first\_elem}}{remove\_first\_elem}}\label{remove_first_elem}

\texttt{remove\_first\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_first\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_first\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_keys}}{remove\_keys}}\label{remove_keys}

\texttt{remove\_keys} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_str}}{remove\_str}}\label{remove_str}

\texttt{remove\_str} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_vowels}}{remove\_vowels}}\label{remove_vowels}

\texttt{remove\_vowels} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_vowels $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_vowels |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{remove\_whitespace}}{remove\_whitespace}}\label{remove_whitespace}

\texttt{remove\_whitespace} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = remove\_whitespace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map remove\_whitespace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{renamenx}}{renamenx}}\label{renamenx}

\texttt{renamenx} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = renamenx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map renamenx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{renyi\_divergence\_step}}{renyi\_divergence\_step}}\label{renyi_divergence_step}

\texttt{renyi\_divergence\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = renyi\_divergence\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map renyi\_divergence\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rep}}{rep}}\label{rep}

\texttt{rep} --- r base builtin. Alias for \texttt{rep\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rep $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rep |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rep\_fn}}{rep\_fn}}\label{rep_fn}

\texttt{rep\_fn} --- repeat a value N times. Like R\textquotesingle s
rep().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @r = @\{rep\_fn(0, 10)\}   \# ten zeros}
\NormalTok{my @s = @\{rep\_fn("x", 5)\}  \# five "x"s}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repa}}{repa}}\label{repa}

\texttt{repa} --- javascript array/object methods builtin. Alias for
\texttt{replace\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repdigit}}{repdigit}}\label{repdigit}

\texttt{repdigit} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repdigit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repdigit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repeat}}{repeat}}\label{repeat}

\texttt{repeat} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repeat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repeat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repeat\_elem}}{repeat\_elem}}\label{repeat_elem}

\texttt{repeat\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repeat\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repeat\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repeat\_list}}{repeat\_list}}\label{repeat_list}

\texttt{repeat\_list} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repeat\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repeat\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repeat\_string}}{repeat\_string}}\label{repeat_string}

\texttt{repeat\_string} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repeat\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repeat\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repeated\_game\_avg\_payoff}}{repeated\_game\_avg\_payoff}}\label{repeated_game_avg_payoff}

\texttt{repeated\_game\_avg\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repeated\_game\_avg\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repeated\_game\_avg\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repeatedly}}{repeatedly}}\label{repeatedly}

\texttt{repeatedly} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repeatedly $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repeatedly |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replace\_all\_str}}{replace\_all\_str}}\label{replace_all_str}

\texttt{replace\_all\_str} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replace\_all\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replace\_all\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replace\_at}}{replace\_at}}\label{replace_at}

\texttt{replace\_at} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replace\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replace\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replace\_at\_index}}{replace\_at\_index}}\label{replace_at_index}

\texttt{replace\_at\_index} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replace\_at\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replace\_at\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replace\_first}}{replace\_first}}\label{replace_first}

\texttt{replace\_first} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replace\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replace\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replace\_n\_times}}{replace\_n\_times}}\label{replace_n_times}

\texttt{replace\_n\_times} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replace\_n\_times $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replace\_n\_times |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replace\_regex}}{replace\_regex}}\label{replace_regex}

\texttt{replace\_regex} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replace\_regex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replace\_regex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replicate\_val}}{replicate\_val}}\label{replicate_val}

\texttt{replicate\_val} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replicate\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replicate\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replicator\_dynamics\_step}}{replicator\_dynamics\_step}}\label{replicator_dynamics_step}

\texttt{replicator\_dynamics\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replicator\_dynamics\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replicator\_dynamics\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repln}}{repln}}\label{repln}

\texttt{repln} --- extended stdlib builtin. Alias for
\texttt{replace\_n\_times}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repln $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repln |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{replre}}{replre}}\label{replre}

\texttt{replre} --- extended stdlib builtin. Alias for
\texttt{replace\_regex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = replre $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map replre |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{representation\_dim\_step}}{representation\_dim\_step}}\label{representation_dim_step}

\texttt{representation\_dim\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = representation\_dim\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map representation\_dim\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repunit}}{repunit}}\label{repunit}

\texttt{repunit} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repunit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repunit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{repv}}{repv}}\label{repv}

\texttt{repv} --- haskell list functions builtin. Alias for
\texttt{replicate\_val}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = repv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map repv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resample}}{resample}}\label{resample}

\texttt{resample(\textbackslash{}@signal,\ \$factor)} --- resamples
signal by a rational factor. Factor \textgreater{} 1 upsamples, factor
\textless{} 1 downsamples. Uses linear interpolation.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $up = resample(\textbackslash{}@signal, 2)     \# double sample rate}
\NormalTok{my $down = resample(\textbackslash{}@signal, 0.5) \# halve sample rate}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resample\_linear}}{resample\_linear}}\label{resample_linear}

\texttt{resample\_linear} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resample\_linear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resample\_linear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resample\_nearest}}{resample\_nearest}}\label{resample_nearest}

\texttt{resample\_nearest} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resample\_nearest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resample\_nearest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resample\_poly\_step}}{resample\_poly\_step}}\label{resample_poly_step}

\texttt{resample\_poly\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resample\_poly\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resample\_poly\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reserve\_prospective}}{reserve\_prospective}}\label{reserve_prospective}

\texttt{reserve\_prospective} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reserve\_prospective $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reserve\_prospective |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reserve\_retrospective}}{reserve\_retrospective}}\label{reserve_retrospective}

\texttt{reserve\_retrospective} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reserve\_retrospective $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reserve\_retrospective |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reservoir\_sample}}{reservoir\_sample}}\label{reservoir_sample}

\texttt{reservoir\_sample} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reservoir\_sample $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reservoir\_sample |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reset}}{reset}}\label{reset}

\texttt{reset} --- process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reset $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reset |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resfreq}}{resfreq}}\label{resfreq}

\texttt{resfreq} --- physics formulas builtin. Alias for
\texttt{resonant\_frequency}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resfreq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resfreq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reshape\_dim}}{reshape\_dim}}\label{reshape_dim}

\texttt{reshape\_dim} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reshape\_dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reshape\_dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{residuals\_compute}}{residuals\_compute}}\label{residuals_compute}

\texttt{residuals\_compute} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = residuals\_compute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map residuals\_compute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resistance\_parallel}}{resistance\_parallel}}\label{resistance_parallel}

\texttt{resistance\_parallel} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resistance\_parallel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resistance\_parallel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resistance\_series}}{resistance\_series}}\label{resistance_series}

\texttt{resistance\_series} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resistance\_series $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resistance\_series |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resolution\_step}}{resolution\_step}}\label{resolution_step}

\texttt{resolution\_step} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resolution\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resolution\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resonance\_count}}{resonance\_count}}\label{resonance_count}

\texttt{resonance\_count} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resonance\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resonance\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{resonant\_frequency}}{resonant\_frequency}}\label{resonant_frequency}

\texttt{resonant\_frequency} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = resonant\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map resonant\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rest}}{rest}}\label{rest}

\texttt{rest} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rest\_energy}}{rest\_energy}}\label{rest_energy}

\texttt{rest\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rest\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rest\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{restenergy}}{restenergy}}\label{restenergy}

\texttt{restenergy} --- physics formulas builtin. Alias for
\texttt{rest\_energy}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = restenergy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map restenergy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rev}}{rev}}\label{rev}

\texttt{rev} --- short aliases builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rev $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rev |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rev\_str}}{rev\_str}}\label{rev_str}

\texttt{rev\_str} --- trivial string ops builtin. Alias for
\texttt{reverse\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rev\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rev\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rev\_vec}}{rev\_vec}}\label{rev_vec}

\texttt{rev\_vec} --- r base builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rev\_vec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rev\_vec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{revenue\_equivalence\_check}}{revenue\_equivalence\_check}}\label{revenue_equivalence_check}

\texttt{revenue\_equivalence\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = revenue\_equivalence\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map revenue\_equivalence\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_delete\_step}}{reverse\_delete\_step}}\label{reverse_delete_step}

\texttt{reverse\_delete\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_delete\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_delete\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_each}}{reverse\_each}}\label{reverse_each}

\texttt{reverse\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_each\_word}}{reverse\_each\_word}}\label{reverse_each_word}

\texttt{reverse\_each\_word} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_each\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_each\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_list}}{reverse\_list}}\label{reverse_list}

\texttt{reverse\_list} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_str}}{reverse\_str}}\label{reverse_str}

\texttt{reverse\_str} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_transcribe}}{reverse\_transcribe}}\label{reverse_transcribe}

\texttt{reverse\_transcribe} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_transcribe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_transcribe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reverse\_words}}{reverse\_words}}\label{reverse_words}

\texttt{reverse\_words} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reverse\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reverse\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{revwords}}{revwords}}\label{revwords}

\texttt{revwords} --- string processing (uncategorized batch) builtin.
Alias for \texttt{reverse\_each\_word}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = revwords $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map revwords |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rexp}}{rexp}}\label{rexp}

\texttt{rexp} --- generate n random exponential variates. Args: n {[},
rate{]}. Like R\textquotesingle s rexp().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rexp(100, 0.5)\}       \# rate=0.5 (mean=2)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{reynolds\_full\_number}}{reynolds\_full\_number}}\label{reynolds_full_number}

\texttt{reynolds\_full\_number} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = reynolds\_full\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map reynolds\_full\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rf}}{rf}}\label{rf}

\texttt{rf} --- generate n random F variates. Args: n, d1, d2. Like
R\textquotesingle s rf().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rf(100, 5, 10)\}       \# F(5,10)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rfact}}{rfact}}\label{rfact}

\texttt{rfact} --- math formulas builtin. Alias for
\texttt{rising\_factorial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rfact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rfact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rfc3339}}{rfc3339}}\label{rfc3339}

\texttt{rfc3339} --- batch 10 builtin. Alias for
\texttt{rfc3339\_format}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rfc3339 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rfc3339 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rfc3339\_format}}{rfc3339\_format}}\label{rfc3339_format}

\texttt{rfc3339\_format} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rfc3339\_format $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rfc3339\_format |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rfc3339\_parse}}{rfc3339\_parse}}\label{rfc3339_parse}

\texttt{rfc3339\_parse} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rfc3339\_parse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rfc3339\_parse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rg\_radius\_of\_gyration}}{rg\_radius\_of\_gyration}}\label{rg_radius_of_gyration}

\texttt{rg\_radius\_of\_gyration} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rg\_radius\_of\_gyration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rg\_radius\_of\_gyration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgamma}}{rgamma}}\label{rgamma}

\texttt{rgamma} --- generate n random gamma variates. Args: n, shape
{[}, scale{]}. Like R\textquotesingle s rgamma().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rgamma(100, 2, 1)\}    \# Gamma(2,1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb}}{rgb}}\label{rgb}

\texttt{rgb} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rgb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb2hsl}}{rgb2hsl}}\label{rgb2hsl}

\texttt{rgb2hsl} --- color operations builtin. Alias for
\texttt{rgb\_to\_hsl}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb2hsl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rgb2hsl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb2hsv}}{rgb2hsv}}\label{rgb2hsv}

\texttt{rgb2hsv} --- color operations builtin. Alias for
\texttt{rgb\_to\_hsv}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb2hsv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rgb2hsv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_cmyk}}{rgb\_to\_cmyk}}\label{rgb_to_cmyk}

\texttt{rgb\_to\_cmyk} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_cmyk $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_hex}}{rgb\_to\_hex}}\label{rgb_to_hex}

\texttt{rgb\_to\_hex} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_hex $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_hsl}}{rgb\_to\_hsl}}\label{rgb_to_hsl}

\texttt{rgb\_to\_hsl} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_hsl $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_hsv}}{rgb\_to\_hsv}}\label{rgb_to_hsv}

\texttt{rgb\_to\_hsv} --- color operations builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_hsv $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_oklab}}{rgb\_to\_oklab}}\label{rgb_to_oklab}

\texttt{rgb\_to\_oklab} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_oklab $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_xyz}}{rgb\_to\_xyz}}\label{rgb_to_xyz}

\texttt{rgb\_to\_xyz} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_xyz $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_yiq}}{rgb\_to\_yiq}}\label{rgb_to_yiq}

\texttt{rgb\_to\_yiq} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_yiq $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_yuv}}{rgb\_to\_yuv}}\label{rgb_to_yuv}

\texttt{rgb\_to\_yuv} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_yuv $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgb\_to\_yuv601}}{rgb\_to\_yuv601}}\label{rgb_to_yuv601}

\texttt{rgb\_to\_yuv601} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rgb\_to\_yuv601 $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rgeom}}{rgeom}}\label{rgeom}

\texttt{rgeom} --- generate n random geometric variates. Args: n, prob.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rgeom(100, 0.3)\}      \# trials until first success}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rho}}{rho}}\label{rho}

\texttt{spearman} (aliases \texttt{spearman\_corr}, \texttt{rho})
computes Spearman\textquotesingle s rank correlation coefficient between
two samples.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p rho([1,2,3,4,5], [5,6,7,8,7])  \# \textasciitilde{}0.82}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rhumb\_line\_bearing}}{rhumb\_line\_bearing}}\label{rhumb_line_bearing}

\texttt{rhumb\_line\_bearing} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rhumb\_line\_bearing $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rhumb\_line\_bearing |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ricci\_identity\_step}}{ricci\_identity\_step}}\label{ricci_identity_step}

\texttt{ricci\_identity\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ricci\_identity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ricci\_identity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ricci\_tensor\_step\_zero}}{ricci\_tensor\_step\_zero}}\label{ricci_tensor_step_zero}

\texttt{ricci\_tensor\_step\_zero} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ricci\_tensor\_step\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ricci\_tensor\_step\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{richardson\_number\_step}}{richardson\_number\_step}}\label{richardson_number_step}

\texttt{richardson\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = richardson\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map richardson\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{richter\_local\_ml}}{richter\_local\_ml}}\label{richter_local_ml}

\texttt{richter\_local\_ml} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = richter\_local\_ml $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map richter\_local\_ml |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ricker\_wavelet}}{ricker\_wavelet}}\label{ricker_wavelet}

\texttt{ricker\_wavelet} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ricker\_wavelet $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ricker\_wavelet |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ridders}}{ridders}}\label{ridders}

\texttt{ridders} --- batch 19 builtin. Alias for \texttt{ridders\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ridders $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ridders |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ridders\_root}}{ridders\_root}}\label{ridders_root}

\texttt{ridders\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ridders\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ridders\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ridx}}{ridx}}\label{ridx}

\texttt{ridx} --- python/ruby stdlib builtin. Alias for
\texttt{rindex\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ridx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ridx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{riemann\_curvature\_normal\_form}}{riemann\_curvature\_normal\_form}}\label{riemann_curvature_normal_form}

\texttt{riemann\_curvature\_normal\_form} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = riemann\_curvature\_normal\_form $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map riemann\_curvature\_normal\_form |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{riemann\_tensor\_step\_zero}}{riemann\_tensor\_step\_zero}}\label{riemann_tensor_step_zero}

\texttt{riemann\_tensor\_step\_zero} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = riemann\_tensor\_step\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map riemann\_tensor\_step\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{riemann\_xi}}{riemann\_xi}}\label{riemann_xi}

\texttt{riemann\_xi} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = riemann\_xi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map riemann\_xi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{riffle}}{riffle}}\label{riffle}

\texttt{riffle} --- collection helpers (trivial) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = riffle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map riffle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{right\_str}}{right\_str}}\label{right_str}

\texttt{right\_str} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = right\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map right\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rindex\_fn}}{rindex\_fn}}\label{rindex_fn}

\texttt{rindex\_fn} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rindex\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rindex\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rising\_factorial}}{rising\_factorial}}\label{rising_factorial}

\texttt{rising\_factorial} --- math formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rising\_factorial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rising\_factorial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{risk\_ratio\_2x2}}{risk\_ratio\_2x2}}\label{risk_ratio_2x2}

\texttt{risk\_ratio\_2x2} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = risk\_ratio\_2x2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map risk\_ratio\_2x2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rjt}}{rjt}}\label{rjt}

\texttt{rjt} --- extended stdlib builtin. Alias for
\texttt{rjust\_text}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rjt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rjt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rjust}}{rjust}}\label{rjust}

\texttt{rjust} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rjust $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rjust |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rjust\_text}}{rjust\_text}}\label{rjust_text}

\texttt{rjust\_text} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rjust\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rjust\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rk4}}{rk4}}\label{rk4}

\texttt{rk4} (aliases \texttt{runge\_kutta}, \texttt{rk4\_ode}) solves
an ODE dy/dt = f(t,y) using 4th-order Runge-Kutta. Returns {[}{[}t,y{]},
...{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{\# dy/dt = {-}y, y(0) = 1 → y = e\^{}({-}t)}
\NormalTok{my $sol = rk4(fn \{ {-}$\_[1] \}, 0, 1, 0.1, 100)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rk45\_cash\_karp}}{rk45\_cash\_karp}}\label{rk45_cash_karp}

\texttt{rk45\_cash\_karp} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rk45\_cash\_karp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rk45\_cash\_karp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rk4\_single}}{rk4\_single}}\label{rk4_single}

\texttt{rk4\_single} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rk4\_single $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rk4\_single |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rk\_combine}}{rk\_combine}}\label{rk_combine}

\texttt{rk\_combine} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rk\_combine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rk\_combine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rkck}}{rkck}}\label{rkck}

\texttt{rkck} --- batch 19 builtin. Alias for \texttt{rk45\_cash\_karp}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rkck $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rkck |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rkf45\_error}}{rkf45\_error}}\label{rkf45_error}

\texttt{rkf45\_error} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rkf45\_error $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rkf45\_error |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rl\_tau}}{rl\_tau}}\label{rl_tau}

\texttt{rl\_tau} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rl\_tau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rl\_tau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rl\_time\_constant}}{rl\_time\_constant}}\label{rl_time_constant}

\texttt{rl\_time\_constant} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rl\_time\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rl\_time\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rld}}{rld}}\label{rld}

\texttt{rld} --- collection more builtin. Alias for
\texttt{run\_length\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rld $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rld |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rld\_str}}{rld\_str}}\label{rld_str}

\texttt{rld\_str} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{run\_length\_decode\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rld\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rld\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rle}}{rle}}\label{rle}

\texttt{rle} --- collection more builtin. Alias for
\texttt{run\_length\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rle\_str}}{rle\_str}}\label{rle_str}

\texttt{rle\_str} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{run\_length\_encode\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rle\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rle\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rlnorm}}{rlnorm}}\label{rlnorm}

\texttt{rlnorm} --- generate n random log-normal variates. Args: n {[},
mu, sigma{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rlnorm(100, 0, 1)\}    \# LogN(0,1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rltau}}{rltau}}\label{rltau}

\texttt{rltau} --- physics formulas builtin. Alias for
\texttt{rl\_time\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rltau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rltau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rmall}}{rmall}}\label{rmall}

\texttt{rmall} --- extended stdlib builtin. Alias for
\texttt{remove\_all\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rmall $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rmall |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rmcons}}{rmcons}}\label{rmcons}

\texttt{rmcons} --- string processing (uncategorized batch) builtin.
Alias for \texttt{remove\_consonants}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rmcons $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rmcons |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rms}}{rms}}\label{rms}

\texttt{rms} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rms $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rms |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rmse}}{rmse}}\label{rmse}

\texttt{rmse} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rmse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rmse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rmvowel}}{rmvowel}}\label{rmvowel}

\texttt{rmvowel} --- string processing (uncategorized batch) builtin.
Alias for \texttt{remove\_vowels}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rmvowel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rmvowel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rmws}}{rmws}}\label{rmws}

\texttt{rmws} --- extended stdlib builtin. Alias for
\texttt{remove\_whitespace}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rmws $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rmws |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rngcmp}}{rngcmp}}\label{rngcmp}

\texttt{rngcmp} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{range\_compress}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rngcmp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rngcmp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rngexp}}{rngexp}}\label{rngexp}

\texttt{rngexp} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{range\_expand}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rngexp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rngexp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rnk}}{rnk}}\label{rnk}

\texttt{rnk} --- extended stdlib builtin. Alias for \texttt{rank}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rnk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rnk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rnorm}}{rnorm}}\label{rnorm}

\texttt{rnorm} --- generate n random normal variates. Args: n {[}, mu,
sigma{]}. Like R\textquotesingle s rnorm().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rnorm(1000)\}          \# 1000 standard normal}
\NormalTok{my @y = @\{rnorm(100, 50, 10)\}   \# mean=50, sd=10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roberts\_kernel\_value}}{roberts\_kernel\_value}}\label{roberts_kernel_value}

\texttt{roberts\_kernel\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roberts\_kernel\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roberts\_kernel\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{robinson\_project}}{robinson\_project}}\label{robinson_project}

\texttt{robinson\_project} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = robinson\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map robinson\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{robinson\_schensted\_pair}}{robinson\_schensted\_pair}}\label{robinson_schensted_pair}

\texttt{robinson\_schensted\_pair} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = robinson\_schensted\_pair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map robinson\_schensted\_pair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{robust\_scale}}{robust\_scale}}\label{robust_scale}

\texttt{robust\_scale} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = robust\_scale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map robust\_scale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{robust\_se\_huber\_white}}{robust\_se\_huber\_white}}\label{robust_se_huber_white}

\texttt{robust\_se\_huber\_white} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = robust\_se\_huber\_white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map robust\_se\_huber\_white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roche\_limit\_fluid}}{roche\_limit\_fluid}}\label{roche_limit_fluid}

\texttt{roche\_limit\_fluid} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roche\_limit\_fluid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roche\_limit\_fluid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roche\_limit\_rigid}}{roche\_limit\_rigid}}\label{roche_limit_rigid}

\texttt{roche\_limit\_rigid} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roche\_limit\_rigid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roche\_limit\_rigid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roi}}{roi}}\label{roi}

\texttt{roi} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roll\_n}}{roll\_n}}\label{roll_n}

\texttt{roll\_n} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roll\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roll\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roman}}{roman}}\label{roman}

\texttt{roman} --- roman numerals builtin. Alias for
\texttt{int\_to\_roman}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roman\_add}}{roman\_add}}\label{roman_add}

\texttt{roman\_add} --- roman numerals builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roman\_add $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roman\_add |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roman\_decode}}{roman\_decode}}\label{roman_decode}

\texttt{roman\_decode} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roman\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roman\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roman\_encode}}{roman\_encode}}\label{roman_encode}

\texttt{roman\_encode} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roman\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roman\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roman\_numeral\_list}}{roman\_numeral\_list}}\label{roman_numeral_list}

\texttt{roman\_numeral\_list} --- roman numerals builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roman\_numeral\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roman\_numeral\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roman\_to\_int}}{roman\_to\_int}}\label{roman_to_int}

\texttt{roman\_to\_int} --- roman numerals builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roman\_to\_int $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{romanlist}}{romanlist}}\label{romanlist}

\texttt{romanlist} --- roman numerals builtin. Alias for
\texttt{roman\_numeral\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = romanlist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map romanlist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{romberg\_quad}}{romberg\_quad}}\label{romberg_quad}

\texttt{romberg\_quad} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = romberg\_quad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map romberg\_quad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roommate\_match\_step}}{roommate\_match\_step}}\label{roommate_match_step}

\texttt{roommate\_match\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roommate\_match\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roommate\_match\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{root\_brentq}}{root\_brentq}}\label{root_brentq}

\texttt{root\_brentq} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = root\_brentq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map root\_brentq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{root\_newton}}{root\_newton}}\label{root_newton}

\texttt{root\_newton} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = root\_newton $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map root\_newton |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{root\_secant}}{root\_secant}}\label{root_secant}

\texttt{root\_secant} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = root\_secant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map root\_secant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{root\_system\_count}}{root\_system\_count}}\label{root_system_count}

\texttt{root\_system\_count} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = root\_system\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map root\_system\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ros2\_step}}{ros2\_step}}\label{ros2_step}

\texttt{ros2\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ros2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ros2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rot13}}{rot13}}\label{rot13}

\texttt{rot13} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rot13 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rot13 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rot47}}{rot47}}\label{rot47}

\texttt{rot47} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rot47 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rot47 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rotate}}{rotate}}\label{rotate}

\texttt{rotate} --- collection helpers (trivial) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rotate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rotate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rotate\_axis}}{rotate\_axis}}\label{rotate_axis}

\texttt{rotate\_axis} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rotate\_axis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rotate\_axis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rotate\_point}}{rotate\_point}}\label{rotate_point}

\texttt{rotate\_point} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rotate\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rotate\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{roulette\_wheel\_select\_index}}{roulette\_wheel\_select\_index}}\label{roulette_wheel_select_index}

\texttt{roulette\_wheel\_select\_index} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = roulette\_wheel\_select\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map roulette\_wheel\_select\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{round}}{round}}\label{round}

\texttt{round} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{round\_each}}{round\_each}}\label{round_each}

\texttt{round\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = round\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map round\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{round\_to}}{round\_to}}\label{round_to}

\texttt{round\_to} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = round\_to $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map round\_to |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rowMeans}}{rowMeans}}\label{rowmeans}

\texttt{row\_means} (alias \texttt{rowMeans}) --- mean of each row. Like
R\textquotesingle s rowMeans().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p rowMeans([[2,4],[6,8]])  \# [3, 7]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rowSums}}{rowSums}}\label{rowsums}

\texttt{row\_sums} (alias \texttt{rowSums}) --- sum of each row in a
matrix. Like R\textquotesingle s rowSums().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p row\_sums([[1,2,3],[4,5,6]])  \# [6, 15]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rpad}}{rpad}}\label{rpad}

\texttt{rpad} --- trivial string ops builtin. Alias for
\texttt{pad\_right}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rpad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rpad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rpn}}{rpn}}\label{rpn}

\texttt{rpn} --- algorithms / puzzles builtin. Alias for
\texttt{eval\_rpn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rpn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rpn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rpois}}{rpois}}\label{rpois}

\texttt{rpois} --- generate n random Poisson variates. Args: n, lambda.
Like R\textquotesingle s rpois().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rpois(100, 5)\}        \# Poisson with mean 5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rptd}}{rptd}}\label{rptd}

\texttt{rptd} --- algebraic match builtin. Alias for
\texttt{repeatedly}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rptd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rptd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rpush}}{rpush}}\label{rpush}

\texttt{rpush} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rpush $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rpush |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rrt\_extend}}{rrt\_extend}}\label{rrt_extend}

\texttt{rrt\_extend} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rrt\_extend $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rrt\_extend |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rrt\_star\_rewire}}{rrt\_star\_rewire}}\label{rrt_star_rewire}

\texttt{rrt\_star\_rewire} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rrt\_star\_rewire $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rrt\_star\_rewire |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rrule\_next\_occurrence}}{rrule\_next\_occurrence}}\label{rrule_next_occurrence}

\texttt{rrule\_next\_occurrence} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rrule\_next\_occurrence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rrule\_next\_occurrence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_d\_from\_e}}{rsa\_d\_from\_e}}\label{rsa_d_from_e}

\texttt{rsa\_d\_from\_e} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rsa\_d\_from\_e $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rsa\_d\_from\_e |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_decrypt\_pkcs1}}{rsa\_decrypt\_pkcs1}}\label{rsa_decrypt_pkcs1}

\texttt{rsa\_decrypt\_pkcs1} decrypts RSA-PKCS1v15 ciphertext.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $plain = rsa\_decrypt\_pkcs1($priv, $cipher)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_encrypt\_pkcs1}}{rsa\_encrypt\_pkcs1}}\label{rsa_encrypt_pkcs1}

\texttt{rsa\_encrypt\_pkcs1} encrypts with legacy RSA-PKCS1v15 padding.
Only for compatibility with old systems --- prefer OAEP.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $cipher = rsa\_encrypt\_pkcs1($pub, "data")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsa\_encrypt\_simple}}{rsa\_encrypt\_simple}}\label{rsa_encrypt_simple}

\texttt{rsa\_encrypt\_simple} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rsa\_encrypt\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rsa\_encrypt\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsamp}}{rsamp}}\label{rsamp}

\texttt{rsamp} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{reservoir\_sample}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rsamp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rsamp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsk\_size}}{rsk\_size}}\label{rsk_size}

\texttt{rsk\_size} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rsk\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rsk\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rst}}{rst}}\label{rst}

\texttt{rst} --- algebraic match builtin. Alias for \texttt{rest}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rsun}}{rsun}}\label{rsun}

\texttt{rsun} --- physics constants builtin. Alias for
\texttt{sun\_radius}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rsun $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rsun |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rt}}{rt}}\label{rt}

\texttt{rt} --- generate n random Student\textquotesingle s t variates.
Args: n, df. Like R\textquotesingle s rt().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rt(100, 10)\}          \# t with 10 df}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rt\_effective}}{rt\_effective}}\label{rt_effective}

\texttt{rt\_effective} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rt\_effective $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rt\_effective |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rt\_serial\_interval}}{rt\_serial\_interval}}\label{rt_serial_interval}

\texttt{rt\_serial\_interval} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rt\_serial\_interval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rt\_serial\_interval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ruin\_probability\_lundberg}}{ruin\_probability\_lundberg}}\label{ruin_probability_lundberg}

\texttt{ruin\_probability\_lundberg} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ruin\_probability\_lundberg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ruin\_probability\_lundberg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{run\_length\_decode}}{run\_length\_decode}}\label{run_length_decode}

\texttt{run\_length\_decode} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = run\_length\_decode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map run\_length\_decode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{run\_length\_decode\_str}}{run\_length\_decode\_str}}\label{run_length_decode_str}

\texttt{run\_length\_decode\_str} --- matrix operations (uncategorized
batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = run\_length\_decode\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map run\_length\_decode\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{run\_length\_encode}}{run\_length\_encode}}\label{run_length_encode}

\texttt{run\_length\_encode} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = run\_length\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map run\_length\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{run\_length\_encode\_str}}{run\_length\_encode\_str}}\label{run_length_encode_str}

\texttt{run\_length\_encode\_str} --- matrix operations (uncategorized
batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = run\_length\_encode\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map run\_length\_encode\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{run\_off\_triangle\_step}}{run\_off\_triangle\_step}}\label{run_off_triangle_step}

\texttt{run\_off\_triangle\_step} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = run\_off\_triangle\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map run\_off\_triangle\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{runif}}{runif}}\label{runif}

\texttt{runif} --- generate n random uniform variates. Args: n {[}, min,
max{]}. Like R\textquotesingle s runif().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{runif(100, 0, 1)\}     \# 100 uniform [0,1]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{running\_max}}{running\_max}}\label{running_max}

\texttt{running\_max} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = running\_max $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map running\_max |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{running\_mean}}{running\_mean}}\label{running_mean}

\texttt{running\_mean} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = running\_mean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map running\_mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{running\_min}}{running\_min}}\label{running_min}

\texttt{running\_min} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = running\_min $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map running\_min |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{running\_reduce}}{running\_reduce}}\label{running_reduce}

\texttt{running\_reduce} --- additional missing stdlib functions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = running\_reduce $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map running\_reduce |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{running\_variance}}{running\_variance}}\label{running_variance}

\texttt{running\_variance} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = running\_variance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map running\_variance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{runred}}{runred}}\label{runred}

\texttt{runred} --- additional missing stdlib functions builtin. Alias
for \texttt{running\_reduce}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = runred $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map runred |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rweibull}}{rweibull}}\label{rweibull}

\texttt{rweibull} --- generate n random Weibull variates. Args: n, shape
{[}, scale{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = @\{rweibull(100, 2, 1)\}  \# Weibull(2,1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rx\_gate}}{rx\_gate}}\label{rx_gate}

\texttt{rx\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rx\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rx\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rxn\_q}}{rxn\_q}}\label{rxn_q}

\texttt{rxn\_q} --- batch 21 builtin. Alias for
\texttt{reaction\_quotient}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rxn\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rxn\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ry\_gate}}{ry\_gate}}\label{ry_gate}

\texttt{ry\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ry\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ry\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rydberg}}{rydberg}}\label{rydberg}

\texttt{rydberg} --- physics constants builtin. Alias for
\texttt{rydberg\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rydberg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rydberg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rydberg\_constant}}{rydberg\_constant}}\label{rydberg_constant}

\texttt{rydberg\_constant} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rydberg\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rydberg\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rydberg\_lambda}}{rydberg\_lambda}}\label{rydberg_lambda}

\texttt{rydberg\_lambda} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rydberg\_lambda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rydberg\_lambda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ryu\_takayanagi\_step}}{ryu\_takayanagi\_step}}\label{ryu_takayanagi_step}

\texttt{ryu\_takayanagi\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ryu\_takayanagi\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ryu\_takayanagi\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{rz\_gate}}{rz\_gate}}\label{rz_gate}

\texttt{rz\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = rz\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map rz\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s1}}{s1}}\label{s1}

\texttt{s1} --- crypto / encoding builtin. Alias for \texttt{sha1}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s224}}{s224}}\label{s224}

\texttt{s224} --- crypto / encoding builtin. Alias for \texttt{sha224}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s224 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s224 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s256}}{s256}}\label{s256}

\texttt{s256} --- crypto / encoding builtin. Alias for \texttt{sha256}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s256 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s256 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s2\_cell\_at\_lat\_lng}}{s2\_cell\_at\_lat\_lng}}\label{s2_cell_at_lat_lng}

\texttt{s2\_cell\_at\_lat\_lng} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s2\_cell\_at\_lat\_lng $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s2\_cell\_at\_lat\_lng |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s2\_cell\_id}}{s2\_cell\_id}}\label{s2_cell_id}

\texttt{s2\_cell\_id} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s2\_cell\_id $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s2\_cell\_id |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s2\_cell\_neighbors}}{s2\_cell\_neighbors}}\label{s2_cell_neighbors}

\texttt{s2\_cell\_neighbors} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s2\_cell\_neighbors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s2\_cell\_neighbors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s2c}}{s2c}}\label{s2c}

\texttt{s2c} --- string processing (uncategorized batch) builtin. Alias
for \texttt{snake\_to\_camel}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s2c $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s2c |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s384}}{s384}}\label{s384}

\texttt{s384} --- crypto / encoding builtin. Alias for \texttt{sha384}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s384 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s384 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s512}}{s512}}\label{s512}

\texttt{s512} --- crypto / encoding builtin. Alias for \texttt{sha512}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s512 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map s512 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s\_to\_m}}{s\_to\_m}}\label{s_to_m}

\texttt{s\_to\_m} --- unit conversions builtin. Alias for
\texttt{seconds\_to\_minutes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s\_to\_m $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{s\_to\_ms}}{s\_to\_ms}}\label{s_to_ms}

\texttt{s\_to\_ms} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = s\_to\_ms $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sa\_accept\_prob}}{sa\_accept\_prob}}\label{sa_accept_prob}

\texttt{sa\_accept\_prob} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sa\_accept\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sa\_accept\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sa\_boltzmann\_temp}}{sa\_boltzmann\_temp}}\label{sa_boltzmann_temp}

\texttt{sa\_boltzmann\_temp} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sa\_boltzmann\_temp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sa\_boltzmann\_temp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sa\_cauchy\_temp}}{sa\_cauchy\_temp}}\label{sa_cauchy_temp}

\texttt{sa\_cauchy\_temp} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sa\_cauchy\_temp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sa\_cauchy\_temp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sa\_geometric\_temp}}{sa\_geometric\_temp}}\label{sa_geometric_temp}

\texttt{sa\_geometric\_temp} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sa\_geometric\_temp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sa\_geometric\_temp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sabr\_implied\_vol}}{sabr\_implied\_vol}}\label{sabr_implied_vol}

\texttt{sabr\_implied\_vol} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sabr\_implied\_vol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sabr\_implied\_vol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sadd}}{sadd}}\label{sadd}

\texttt{sadd} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sadd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sadd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{saddle\_point\_check}}{saddle\_point\_check}}\label{saddle_point_check}

\texttt{saddle\_point\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = saddle\_point\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map saddle\_point\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{safe\_div}}{safe\_div}}\label{safe_div}

\texttt{safe\_div} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = safe\_div $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map safe\_div |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{safe\_log}}{safe\_log}}\label{safe_log}

\texttt{safe\_log} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = safe\_log $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map safe\_log |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{safe\_mod}}{safe\_mod}}\label{safe_mod}

\texttt{safe\_mod} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = safe\_mod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map safe\_mod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{safe\_sqrt}}{safe\_sqrt}}\label{safe_sqrt}

\texttt{safe\_sqrt} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = safe\_sqrt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map safe\_sqrt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{salloc}}{salloc}}\label{salloc}

\texttt{salloc} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_alloc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = salloc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map salloc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{salt\_activity\_coefficient}}{salt\_activity\_coefficient}}\label{salt_activity_coefficient}

\texttt{salt\_activity\_coefficient} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = salt\_activity\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map salt\_activity\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sample\_n}}{sample\_n}}\label{sample_n}

\texttt{sample\_n} --- collection (batch 2) builtin. Alias for
\texttt{random\_sample}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sample\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sample\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sample\_one}}{sample\_one}}\label{sample_one}

\texttt{sample\_one} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sample\_one $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sample\_one |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sample\_stddev}}{sample\_stddev}}\label{sample_stddev}

\texttt{sample\_stddev} --- statistics (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sample\_stddev $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sample\_stddev |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sample\_variance}}{sample\_variance}}\label{sample_variance}

\texttt{sample\_variance} --- statistics (extended) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sample\_variance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sample\_variance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sampn}}{sampn}}\label{sampn}

\texttt{sampn} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sampn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sampn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sapply}}{sapply}}\label{sapply}

\texttt{sapply} --- apply a function to each element, return a vector.
Like R\textquotesingle s sapply().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @sq = @\{sapply([1,2,3,4], fn \{ $\_[0] ** 2 \})\}  \# [1,4,9,16]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sarimax\_fit}}{sarimax\_fit}}\label{sarimax_fit}

\texttt{sarimax\_fit} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sarimax\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sarimax\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{saros\_cycle}}{saros\_cycle}}\label{saros_cycle}

\texttt{saros\_cycle} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = saros\_cycle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map saros\_cycle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sarsa\_update}}{sarsa\_update}}\label{sarsa_update}

\texttt{sarsa\_update} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sarsa\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sarsa\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sat01}}{sat01}}\label{sat01}

\texttt{sat01} --- trig / math (batch 2) builtin. Alias for
\texttt{saturate}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sat01 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sat01 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{saturate}}{saturate}}\label{saturate}

\texttt{saturate} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = saturate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map saturate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{saturation\_equivalent\_pt}}{saturation\_equivalent\_pt}}\label{saturation_equivalent_pt}

\texttt{saturation\_equivalent\_pt} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = saturation\_equivalent\_pt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map saturation\_equivalent\_pt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{saturation\_vapor\_pressure}}{saturation\_vapor\_pressure}}\label{saturation_vapor_pressure}

\texttt{saturation\_vapor\_pressure} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = saturation\_vapor\_pressure $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map saturation\_vapor\_pressure |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{save\_pct}}{save\_pct}}\label{save_pct}

\texttt{save\_pct} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = save\_pct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map save\_pct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{savgol\_coef}}{savgol\_coef}}\label{savgol_coef}

\texttt{savgol\_coef} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = savgol\_coef $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map savgol\_coef |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sbranch}}{sbranch}}\label{sbranch}

\texttt{sbranch} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_branch}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sbranch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sbranch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scalar\_curvature\_step}}{scalar\_curvature\_step}}\label{scalar_curvature_step}

\texttt{scalar\_curvature\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scalar\_curvature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scalar\_curvature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale}}{scale}}\label{scale}

\texttt{scale} --- standardize a vector: (x - mean) / sd. Like
R\textquotesingle s scale().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @z = @\{scale([10,20,30])\}  \# [{-}1, 0, 1]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale\_each}}{scale\_each}}\label{scale_each}

\texttt{scale\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scale\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scale\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale\_factor}}{scale\_factor}}\label{scale_factor}

\texttt{scale\_factor} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scale\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scale\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale\_pitches\_major}}{scale\_pitches\_major}}\label{scale_pitches_major}

\texttt{scale\_pitches\_major} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scale\_pitches\_major $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scale\_pitches\_major |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale\_pitches\_minor}}{scale\_pitches\_minor}}\label{scale_pitches_minor}

\texttt{scale\_pitches\_minor} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scale\_pitches\_minor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scale\_pitches\_minor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale\_point}}{scale\_point}}\label{scale_point}

\texttt{scale\_point(\$x,\ \$y,\ \$sx,\ \$sy)} --- scales a 2D point by
factors sx and sy from the origin. Returns {[}\$x*\$sx, \$y*\$sy{]}. Use
for geometric transformations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $p = scale\_point(2, 3, 2, 2)}
\NormalTok{p @$p   \# (4, 6)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scale\_to\_intervals}}{scale\_to\_intervals}}\label{scale_to_intervals}

\texttt{scale\_to\_intervals} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scale\_to\_intervals $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scalept}}{scalept}}\label{scalept}

\texttt{scalept} --- geometry (extended) builtin. Alias for
\texttt{scale\_point}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scalept $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scalept |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scan}}{scan}}\label{scan}

\texttt{scan} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scan\_axis}}{scan\_axis}}\label{scan_axis}

\texttt{scan\_axis} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scan\_axis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scan\_axis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scan\_left}}{scan\_left}}\label{scan_left}

\texttt{scan\_left} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scan\_left $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scan\_left |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scanl}}{scanl}}\label{scanl}

\texttt{scanl} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scanl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scanl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scanr}}{scanr}}\label{scanr}

\texttt{scanr} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scanr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scanr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scard}}{scard}}\label{scard}

\texttt{scard} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scentroid}}{scentroid}}\label{scentroid}

\texttt{spectral\_centroid(\textbackslash{}@spectrum)} (alias
\texttt{scentroid}) --- computes the spectral centroid (center of mass)
of a spectrum. Indicates the
\textquotesingle brightness\textquotesingle{} of a sound. Returns
frequency bin index.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $psd = psd(\textbackslash{}@signal)}
\NormalTok{p scentroid($psd)   \# brightness measure}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schmidt\_number\_step}}{schmidt\_number\_step}}\label{schmidt_number_step}

\texttt{schmidt\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schmidt\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schmidt\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{school\_choice\_match}}{school\_choice\_match}}\label{school_choice_match}

\texttt{school\_choice\_match} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = school\_choice\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map school\_choice\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schottky\_barrier\_height}}{schottky\_barrier\_height}}\label{schottky_barrier_height}

\texttt{schottky\_barrier\_height} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schottky\_barrier\_height $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schottky\_barrier\_height |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schouten\_tensor\_step}}{schouten\_tensor\_step}}\label{schouten_tensor_step}

\texttt{schouten\_tensor\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schouten\_tensor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schouten\_tensor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schreier\_index}}{schreier\_index}}\label{schreier_index}

\texttt{schreier\_index} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schreier\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schreier\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schrodinger\_step\_real}}{schrodinger\_step\_real}}\label{schrodinger_step_real}

\texttt{schrodinger\_step\_real} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schrodinger\_step\_real $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schrodinger\_step\_real |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schulze\_method\_step}}{schulze\_method\_step}}\label{schulze_method_step}

\texttt{schulze\_method\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schulze\_method\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schulze\_method\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schur\_polynomial\_eval}}{schur\_polynomial\_eval}}\label{schur_polynomial_eval}

\texttt{schur\_polynomial\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schur\_polynomial\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schur\_polynomial\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarz}}{schwarz}}\label{schwarz}

\texttt{schwarzschild\_radius(\$mass)} (alias \texttt{schwarz}) ---
event horizon radius rs = 2GM/c² of a black hole.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p schwarz(1.989e30)   \# \textasciitilde{}2954 m (Sun as black hole)}
\NormalTok{p schwarz(5.972e24)   \# \textasciitilde{}0.009 m (Earth as black hole)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_freefall\_time}}{schwarzschild\_freefall\_time}}\label{schwarzschild_freefall_time}

\texttt{schwarzschild\_freefall\_time} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_freefall\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_freefall\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_g\_rr}}{schwarzschild\_g\_rr}}\label{schwarzschild_g_rr}

\texttt{schwarzschild\_g\_rr} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_g\_rr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_g\_rr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_g\_tt}}{schwarzschild\_g\_tt}}\label{schwarzschild_g_tt}

\texttt{schwarzschild\_g\_tt} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_g\_tt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_g\_tt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_isco}}{schwarzschild\_isco}}\label{schwarzschild_isco}

\texttt{schwarzschild\_isco} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_isco $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_isco |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_kruskal\_step}}{schwarzschild\_kruskal\_step}}\label{schwarzschild_kruskal_step}

\texttt{schwarzschild\_kruskal\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_kruskal\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_kruskal\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_radius\_kg}}{schwarzschild\_radius\_kg}}\label{schwarzschild_radius_kg}

\texttt{schwarzschild\_radius\_kg} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_radius\_kg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_radius\_kg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{schwarzschild\_radius\_m}}{schwarzschild\_radius\_m}}\label{schwarzschild_radius_m}

\texttt{schwarzschild\_radius\_m} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = schwarzschild\_radius\_m $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map schwarzschild\_radius\_m |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{score\_test\_stat}}{score\_test\_stat}}\label{score_test_stat}

\texttt{score\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = score\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map score\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{script\_name}}{script\_name}}\label{script_name}

\texttt{script\_name} --- process / env builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = script\_name $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map script\_name |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{scrypt\_round}}{scrypt\_round}}\label{scrypt_round}

\texttt{scrypt\_round} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = scrypt\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map scrypt\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sdbm\_hash}}{sdbm\_hash}}\label{sdbm_hash}

\texttt{sdbm\_hash} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sdbm\_hash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sdbm\_hash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sdiff}}{sdiff}}\label{sdiff}

\texttt{sdiff} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sdiff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sdiff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sdivs}}{sdivs}}\label{sdivs}

\texttt{sdivs} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{sum\_divisors}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sdivs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sdivs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sdns}}{sdns}}\label{sdns}

\texttt{sdns} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_dns}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sdns $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sdns |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sdx}}{sdx}}\label{sdx}

\texttt{sdx} --- extended stdlib builtin. Alias for \texttt{soundex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sdx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sdx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sealed\_bid\_first\_price}}{sealed\_bid\_first\_price}}\label{sealed_bid_first_price}

\texttt{sealed\_bid\_first\_price} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sealed\_bid\_first\_price $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sealed\_bid\_first\_price |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sealed\_bid\_second\_price}}{sealed\_bid\_second\_price}}\label{sealed_bid_second_price}

\texttt{sealed\_bid\_second\_price} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sealed\_bid\_second\_price $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sealed\_bid\_second\_price |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{searchsorted}}{searchsorted}}\label{searchsorted}

\texttt{searchsorted} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = searchsorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map searchsorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seasonal\_decompose}}{seasonal\_decompose}}\label{seasonal_decompose}

\texttt{seasonal\_decompose} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seasonal\_decompose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seasonal\_decompose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seasonal\_diff}}{seasonal\_diff}}\label{seasonal_diff}

\texttt{seasonal\_diff} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seasonal\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seasonal\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec}}{sec}}\label{sec}

\texttt{sec} returns the secant (1/cos) of an angle in radians.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sec(0)  \# 1.0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_2fa\_totp\_window}}{sec\_2fa\_totp\_window}}\label{sec_2fa_totp_window}

\texttt{sec\_2fa\_totp\_window} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_2fa\_totp\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_2fa\_totp\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_account\_lockout\_step}}{sec\_account\_lockout\_step}}\label{sec_account_lockout_step}

\texttt{sec\_account\_lockout\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_account\_lockout\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_account\_lockout\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_acme\_dns\_challenge}}{sec\_acme\_dns\_challenge}}\label{sec_acme_dns_challenge}

\texttt{sec\_acme\_dns\_challenge} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_acme\_dns\_challenge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_acme\_dns\_challenge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_aes\_keyschedule\_step}}{sec\_aes\_keyschedule\_step}}\label{sec_aes_keyschedule_step}

\texttt{sec\_aes\_keyschedule\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_aes\_keyschedule\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_aes\_keyschedule\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_aes\_round\_step}}{sec\_aes\_round\_step}}\label{sec_aes_round_step}

\texttt{sec\_aes\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_aes\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_aes\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_arc\_chain\_step}}{sec\_arc\_chain\_step}}\label{sec_arc_chain_step}

\texttt{sec\_arc\_chain\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_arc\_chain\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_arc\_chain\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_argon2\_block\_step}}{sec\_argon2\_block\_step}}\label{sec_argon2_block_step}

\texttt{sec\_argon2\_block\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_argon2\_block\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_argon2\_block\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_argon2\_memcost}}{sec\_argon2\_memcost}}\label{sec_argon2_memcost}

\texttt{sec\_argon2\_memcost} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_argon2\_memcost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_argon2\_memcost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_argon2\_parallelism}}{sec\_argon2\_parallelism}}\label{sec_argon2_parallelism}

\texttt{sec\_argon2\_parallelism} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_argon2\_parallelism $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_argon2\_parallelism |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_argon2\_state\_advance}}{sec\_argon2\_state\_advance}}\label{sec_argon2_state_advance}

\texttt{sec\_argon2\_state\_advance} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_argon2\_state\_advance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_argon2\_state\_advance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_argon2\_timecost}}{sec\_argon2\_timecost}}\label{sec_argon2_timecost}

\texttt{sec\_argon2\_timecost} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_argon2\_timecost $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_argon2\_timecost |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_balloon\_hash\_step}}{sec\_balloon\_hash\_step}}\label{sec_balloon_hash_step}

\texttt{sec\_balloon\_hash\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_balloon\_hash\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_balloon\_hash\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_basic\_constraints\_ca}}{sec\_basic\_constraints\_ca}}\label{sec_basic_constraints_ca}

\texttt{sec\_basic\_constraints\_ca} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_basic\_constraints\_ca $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_basic\_constraints\_ca |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_bcrypt\_cost\_factor}}{sec\_bcrypt\_cost\_factor}}\label{sec_bcrypt_cost_factor}

\texttt{sec\_bcrypt\_cost\_factor} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_bcrypt\_cost\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_bcrypt\_cost\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_bcrypt\_round\_step}}{sec\_bcrypt\_round\_step}}\label{sec_bcrypt_round_step}

\texttt{sec\_bcrypt\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_bcrypt\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_bcrypt\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_blake3\_chunk\_step}}{sec\_blake3\_chunk\_step}}\label{sec_blake3_chunk_step}

\texttt{sec\_blake3\_chunk\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_blake3\_chunk\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_blake3\_chunk\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_blowfish\_round\_step}}{sec\_blowfish\_round\_step}}\label{sec_blowfish_round_step}

\texttt{sec\_blowfish\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_blowfish\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_blowfish\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_brute\_force\_attempts}}{sec\_brute\_force\_attempts}}\label{sec_brute_force_attempts}

\texttt{sec\_brute\_force\_attempts} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_brute\_force\_attempts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_brute\_force\_attempts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_cbc\_mac\_block\_count}}{sec\_cbc\_mac\_block\_count}}\label{sec_cbc_mac_block_count}

\texttt{sec\_cbc\_mac\_block\_count} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_cbc\_mac\_block\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_cbc\_mac\_block\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_certificate\_chain\_depth}}{sec\_certificate\_chain\_depth}}\label{sec_certificate_chain_depth}

\texttt{sec\_certificate\_chain\_depth} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_certificate\_chain\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_certificate\_chain\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_certificate\_transparency}}{sec\_certificate\_transparency}}\label{sec_certificate_transparency}

\texttt{sec\_certificate\_transparency} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_certificate\_transparency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_certificate\_transparency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_chacha20\_quarterround}}{sec\_chacha20\_quarterround}}\label{sec_chacha20_quarterround}

\texttt{sec\_chacha20\_quarterround} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_chacha20\_quarterround $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_chacha20\_quarterround |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_chachapoly\_nonce\_check}}{sec\_chachapoly\_nonce\_check}}\label{sec_chachapoly_nonce_check}

\texttt{sec\_chachapoly\_nonce\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_chachapoly\_nonce\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_chachapoly\_nonce\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_chosen\_charset\_strength}}{sec\_chosen\_charset\_strength}}\label{sec_chosen_charset_strength}

\texttt{sec\_chosen\_charset\_strength} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_chosen\_charset\_strength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_chosen\_charset\_strength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_cipher\_suite\_strength}}{sec\_cipher\_suite\_strength}}\label{sec_cipher_suite_strength}

\texttt{sec\_cipher\_suite\_strength} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_cipher\_suite\_strength $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_cipher\_suite\_strength |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_command\_injection\_score}}{sec\_command\_injection\_score}}\label{sec_command_injection_score}

\texttt{sec\_command\_injection\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_command\_injection\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_command\_injection\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_complexity\_policy\_score}}{sec\_complexity\_policy\_score}}\label{sec_complexity_policy_score}

\texttt{sec\_complexity\_policy\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_complexity\_policy\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_complexity\_policy\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_cors\_origin\_match}}{sec\_cors\_origin\_match}}\label{sec_cors_origin_match}

\texttt{sec\_cors\_origin\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_cors\_origin\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_cors\_origin\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_credential\_stuffing\_score}}{sec\_credential\_stuffing\_score}}\label{sec_credential_stuffing_score}

\texttt{sec\_credential\_stuffing\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_credential\_stuffing\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_credential\_stuffing\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_crl\_age\_seconds}}{sec\_crl\_age\_seconds}}\label{sec_crl_age_seconds}

\texttt{sec\_crl\_age\_seconds} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_crl\_age\_seconds $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_crl\_age\_seconds |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_csp\_directive\_match}}{sec\_csp\_directive\_match}}\label{sec_csp_directive_match}

\texttt{sec\_csp\_directive\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_csp\_directive\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_csp\_directive\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_csrf\_token\_match}}{sec\_csrf\_token\_match}}\label{sec_csrf_token_match}

\texttt{sec\_csrf\_token\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_csrf\_token\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_csrf\_token\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_dane\_tlsa\_match}}{sec\_dane\_tlsa\_match}}\label{sec_dane_tlsa_match}

\texttt{sec\_dane\_tlsa\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_dane\_tlsa\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_dane\_tlsa\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_des\_round\_step}}{sec\_des\_round\_step}}\label{sec_des_round_step}

\texttt{sec\_des\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_des\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_des\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_diameter\_avp\_step}}{sec\_diameter\_avp\_step}}\label{sec_diameter_avp_step}

\texttt{sec\_diameter\_avp\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_diameter\_avp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_diameter\_avp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_diceware\_word\_index}}{sec\_diceware\_word\_index}}\label{sec_diceware_word_index}

\texttt{sec\_diceware\_word\_index} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_diceware\_word\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_diceware\_word\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_dictionary\_attack\_check}}{sec\_dictionary\_attack\_check}}\label{sec_dictionary_attack_check}

\texttt{sec\_dictionary\_attack\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_dictionary\_attack\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_dictionary\_attack\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_dkim\_signature\_check}}{sec\_dkim\_signature\_check}}\label{sec_dkim_signature_check}

\texttt{sec\_dkim\_signature\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_dkim\_signature\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_dkim\_signature\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_dmarc\_policy\_check}}{sec\_dmarc\_policy\_check}}\label{sec_dmarc_policy_check}

\texttt{sec\_dmarc\_policy\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_dmarc\_policy\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_dmarc\_policy\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_dnssec\_signature\_check}}{sec\_dnssec\_signature\_check}}\label{sec_dnssec_signature_check}

\texttt{sec\_dnssec\_signature\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_dnssec\_signature\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_dnssec\_signature\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_ed25519\_signature\_step}}{sec\_ed25519\_signature\_step}}\label{sec_ed25519_signature_step}

\texttt{sec\_ed25519\_signature\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_ed25519\_signature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_ed25519\_signature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_ed448\_signature\_step}}{sec\_ed448\_signature\_step}}\label{sec_ed448_signature_step}

\texttt{sec\_ed448\_signature\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_ed448\_signature\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_ed448\_signature\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_fido2\_assertion\_check}}{sec\_fido2\_assertion\_check}}\label{sec_fido2_assertion_check}

\texttt{sec\_fido2\_assertion\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_fido2\_assertion\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_fido2\_assertion\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_gcm\_iv\_unique\_check}}{sec\_gcm\_iv\_unique\_check}}\label{sec_gcm_iv_unique_check}

\texttt{sec\_gcm\_iv\_unique\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_gcm\_iv\_unique\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_gcm\_iv\_unique\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_haveibeenpwned\_check}}{sec\_haveibeenpwned\_check}}\label{sec_haveibeenpwned_check}

\texttt{sec\_haveibeenpwned\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_haveibeenpwned\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_haveibeenpwned\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_hotp\_counter\_step}}{sec\_hotp\_counter\_step}}\label{sec_hotp_counter_step}

\texttt{sec\_hotp\_counter\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_hotp\_counter\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_hotp\_counter\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_hpkp\_pin\_match}}{sec\_hpkp\_pin\_match}}\label{sec_hpkp_pin_match}

\texttt{sec\_hpkp\_pin\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_hpkp\_pin\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_hpkp\_pin\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_html\_escape\_check}}{sec\_html\_escape\_check}}\label{sec_html_escape_check}

\texttt{sec\_html\_escape\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_html\_escape\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_html\_escape\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_idle\_timeout\_step}}{sec\_idle\_timeout\_step}}\label{sec_idle_timeout_step}

\texttt{sec\_idle\_timeout\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_idle\_timeout\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_idle\_timeout\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_idor\_check}}{sec\_idor\_check}}\label{sec_idor_check}

\texttt{sec\_idor\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_idor\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_idor\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_imap\_starttls\_check}}{sec\_imap\_starttls\_check}}\label{sec_imap_starttls_check}

\texttt{sec\_imap\_starttls\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_imap\_starttls\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_imap\_starttls\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_jwt\_alg\_safe}}{sec\_jwt\_alg\_safe}}\label{sec_jwt_alg_safe}

\texttt{sec\_jwt\_alg\_safe} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_jwt\_alg\_safe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_jwt\_alg\_safe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_jwt\_kid\_match}}{sec\_jwt\_kid\_match}}\label{sec_jwt_kid_match}

\texttt{sec\_jwt\_kid\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_jwt\_kid\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_jwt\_kid\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_jwt\_signature\_verify}}{sec\_jwt\_signature\_verify}}\label{sec_jwt_signature_verify}

\texttt{sec\_jwt\_signature\_verify} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_jwt\_signature\_verify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_jwt\_signature\_verify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_keccak\_round\_step}}{sec\_keccak\_round\_step}}\label{sec_keccak_round_step}

\texttt{sec\_keccak\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_keccak\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_keccak\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_kerberos\_pac\_check}}{sec\_kerberos\_pac\_check}}\label{sec_kerberos_pac_check}

\texttt{sec\_kerberos\_pac\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_kerberos\_pac\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_kerberos\_pac\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_kerberos\_pre\_auth}}{sec\_kerberos\_pre\_auth}}\label{sec_kerberos_pre_auth}

\texttt{sec\_kerberos\_pre\_auth} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_kerberos\_pre\_auth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_kerberos\_pre\_auth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_kerberos\_ticket\_age}}{sec\_kerberos\_ticket\_age}}\label{sec_kerberos_ticket_age}

\texttt{sec\_kerberos\_ticket\_age} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_kerberos\_ticket\_age $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_kerberos\_ticket\_age |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_keystroke\_timing\_var}}{sec\_keystroke\_timing\_var}}\label{sec_keystroke_timing_var}

\texttt{sec\_keystroke\_timing\_var} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_keystroke\_timing\_var $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_keystroke\_timing\_var |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_ldap\_bind\_step}}{sec\_ldap\_bind\_step}}\label{sec_ldap_bind_step}

\texttt{sec\_ldap\_bind\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_ldap\_bind\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_ldap\_bind\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_login\_throttle\_step}}{sec\_login\_throttle\_step}}\label{sec_login_throttle_step}

\texttt{sec\_login\_throttle\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_login\_throttle\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_login\_throttle\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_oauth2\_pkce\_step}}{sec\_oauth2\_pkce\_step}}\label{sec_oauth2_pkce_step}

\texttt{sec\_oauth2\_pkce\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_oauth2\_pkce\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_oauth2\_pkce\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_oauth2\_state\_validate}}{sec\_oauth2\_state\_validate}}\label{sec_oauth2_state_validate}

\texttt{sec\_oauth2\_state\_validate} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_oauth2\_state\_validate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_oauth2\_state\_validate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_oauth\_nonce\_check}}{sec\_oauth\_nonce\_check}}\label{sec_oauth_nonce_check}

\texttt{sec\_oauth\_nonce\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_oauth\_nonce\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_oauth\_nonce\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_oidc\_id\_token\_age}}{sec\_oidc\_id\_token\_age}}\label{sec_oidc_id_token_age}

\texttt{sec\_oidc\_id\_token\_age} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_oidc\_id\_token\_age $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_oidc\_id\_token\_age |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_p384\_curve\_step}}{sec\_p384\_curve\_step}}\label{sec_p384_curve_step}

\texttt{sec\_p384\_curve\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_p384\_curve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_p384\_curve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_passphrase\_entropy}}{sec\_passphrase\_entropy}}\label{sec_passphrase_entropy}

\texttt{sec\_passphrase\_entropy} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_passphrase\_entropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_passphrase\_entropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_password\_history\_check}}{sec\_password\_history\_check}}\label{sec_password_history_check}

\texttt{sec\_password\_history\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_password\_history\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_password\_history\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_password\_strength\_zxcvbn}}{sec\_password\_strength\_zxcvbn}}\label{sec_password_strength_zxcvbn}

\texttt{sec\_password\_strength\_zxcvbn} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_password\_strength\_zxcvbn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_password\_strength\_zxcvbn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_path\_traversal\_detect}}{sec\_path\_traversal\_detect}}\label{sec_path_traversal_detect}

\texttt{sec\_path\_traversal\_detect} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_path\_traversal\_detect $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_path\_traversal\_detect |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_pbkdf2\_iter}}{sec\_pbkdf2\_iter}}\label{sec_pbkdf2_iter}

\texttt{sec\_pbkdf2\_iter} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_pbkdf2\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_pbkdf2\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_pinning\_compare}}{sec\_pinning\_compare}}\label{sec_pinning_compare}

\texttt{sec\_pinning\_compare} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_pinning\_compare $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_pinning\_compare |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_pki\_path\_validate}}{sec\_pki\_path\_validate}}\label{sec_pki_path_validate}

\texttt{sec\_pki\_path\_validate} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_pki\_path\_validate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_pki\_path\_validate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_pop3\_security\_step}}{sec\_pop3\_security\_step}}\label{sec_pop3_security_step}

\texttt{sec\_pop3\_security\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_pop3\_security\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_pop3\_security\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_radius\_auth\_step}}{sec\_radius\_auth\_step}}\label{sec_radius_auth_step}

\texttt{sec\_radius\_auth\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_radius\_auth\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_radius\_auth\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_revocation\_ocsp\_check}}{sec\_revocation\_ocsp\_check}}\label{sec_revocation_ocsp_check}

\texttt{sec\_revocation\_ocsp\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_revocation\_ocsp\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_revocation\_ocsp\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_saml\_assertion\_age}}{sec\_saml\_assertion\_age}}\label{sec_saml_assertion_age}

\texttt{sec\_saml\_assertion\_age} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_saml\_assertion\_age $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_saml\_assertion\_age |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_san\_match\_count}}{sec\_san\_match\_count}}\label{sec_san_match_count}

\texttt{sec\_san\_match\_count} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_san\_match\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_san\_match\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_scrypt\_n\_param}}{sec\_scrypt\_n\_param}}\label{sec_scrypt_n_param}

\texttt{sec\_scrypt\_n\_param} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_scrypt\_n\_param $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_scrypt\_n\_param |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_scrypt\_p\_param}}{sec\_scrypt\_p\_param}}\label{sec_scrypt_p_param}

\texttt{sec\_scrypt\_p\_param} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_scrypt\_p\_param $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_scrypt\_p\_param |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_scrypt\_r\_param}}{sec\_scrypt\_r\_param}}\label{sec_scrypt_r_param}

\texttt{sec\_scrypt\_r\_param} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_scrypt\_r\_param $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_scrypt\_r\_param |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_secp256k1\_step}}{sec\_secp256k1\_step}}\label{sec_secp256k1_step}

\texttt{sec\_secp256k1\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_secp256k1\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_secp256k1\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_serpent\_round\_step}}{sec\_serpent\_round\_step}}\label{sec_serpent_round_step}

\texttt{sec\_serpent\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_serpent\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_serpent\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_session\_lifetime}}{sec\_session\_lifetime}}\label{sec_session_lifetime}

\texttt{sec\_session\_lifetime} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_session\_lifetime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_session\_lifetime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_sha3\_padding\_step}}{sec\_sha3\_padding\_step}}\label{sec_sha3_padding_step}

\texttt{sec\_sha3\_padding\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_sha3\_padding\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_sha3\_padding\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_smtp\_ssl\_check}}{sec\_smtp\_ssl\_check}}\label{sec_smtp_ssl_check}

\texttt{sec\_smtp\_ssl\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_smtp\_ssl\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_smtp\_ssl\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_spf\_pass\_check}}{sec\_spf\_pass\_check}}\label{sec_spf_pass_check}

\texttt{sec\_spf\_pass\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_spf\_pass\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_spf\_pass\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_sqli\_pattern\_score}}{sec\_sqli\_pattern\_score}}\label{sec_sqli_pattern_score}

\texttt{sec\_sqli\_pattern\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_sqli\_pattern\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_sqli\_pattern\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_ssl3\_disabled\_check}}{sec\_ssl3\_disabled\_check}}\label{sec_ssl3_disabled_check}

\texttt{sec\_ssl3\_disabled\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_ssl3\_disabled\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_ssl3\_disabled\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_tls11\_deprecation\_check}}{sec\_tls11\_deprecation\_check}}\label{sec_tls11_deprecation_check}

\texttt{sec\_tls11\_deprecation\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_tls11\_deprecation\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_tls11\_deprecation\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_tls12\_handshake\_step}}{sec\_tls12\_handshake\_step}}\label{sec_tls12_handshake_step}

\texttt{sec\_tls12\_handshake\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_tls12\_handshake\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_tls12\_handshake\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_tls13\_handshake\_step}}{sec\_tls13\_handshake\_step}}\label{sec_tls13_handshake_step}

\texttt{sec\_tls13\_handshake\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_tls13\_handshake\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_tls13\_handshake\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_tls\_alert\_severity}}{sec\_tls\_alert\_severity}}\label{sec_tls_alert_severity}

\texttt{sec\_tls\_alert\_severity} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_tls\_alert\_severity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_tls\_alert\_severity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_totp\_drift\_check}}{sec\_totp\_drift\_check}}\label{sec_totp_drift_check}

\texttt{sec\_totp\_drift\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_totp\_drift\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_totp\_drift\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_twofish\_round\_step}}{sec\_twofish\_round\_step}}\label{sec_twofish_round_step}

\texttt{sec\_twofish\_round\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_twofish\_round\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_twofish\_round\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_url\_safe\_encode\_check}}{sec\_url\_safe\_encode\_check}}\label{sec_url_safe_encode_check}

\texttt{sec\_url\_safe\_encode\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_url\_safe\_encode\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_url\_safe\_encode\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_webauthn\_attestation\_check}}{sec\_webauthn\_attestation\_check}}\label{sec_webauthn_attestation_check}

\texttt{sec\_webauthn\_attestation\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_webauthn\_attestation\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_webauthn\_attestation\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_x25519\_clamping\_step}}{sec\_x25519\_clamping\_step}}\label{sec_x25519_clamping_step}

\texttt{sec\_x25519\_clamping\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_x25519\_clamping\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_x25519\_clamping\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_x509\_subject\_match}}{sec\_x509\_subject\_match}}\label{sec_x509_subject_match}

\texttt{sec\_x509\_subject\_match} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_x509\_subject\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_x509\_subject\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_xkcd\_passphrase\_score}}{sec\_xkcd\_passphrase\_score}}\label{sec_xkcd_passphrase_score}

\texttt{sec\_xkcd\_passphrase\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_xkcd\_passphrase\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_xkcd\_passphrase\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_xss\_filter\_score}}{sec\_xss\_filter\_score}}\label{sec_xss_filter_score}

\texttt{sec\_xss\_filter\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_xss\_filter\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_xss\_filter\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_xxe\_dtd\_check}}{sec\_xxe\_dtd\_check}}\label{sec_xxe_dtd_check}

\texttt{sec\_xxe\_dtd\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_xxe\_dtd\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_xxe\_dtd\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_xxe\_pattern\_score}}{sec\_xxe\_pattern\_score}}\label{sec_xxe_pattern_score}

\texttt{sec\_xxe\_pattern\_score} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_xxe\_pattern\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_xxe\_pattern\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_yescrypt\_step}}{sec\_yescrypt\_step}}\label{sec_yescrypt_step}

\texttt{sec\_yescrypt\_step} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_yescrypt\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_yescrypt\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sec\_yubikey\_otp\_check}}{sec\_yubikey\_otp\_check}}\label{sec_yubikey_otp_check}

\texttt{sec\_yubikey\_otp\_check} --- batch 51 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sec\_yubikey\_otp\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sec\_yubikey\_otp\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{secant}}{secant}}\label{secant}

\texttt{secant} --- batch 19 builtin. Alias for \texttt{secant\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = secant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map secant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{secant\_root}}{secant\_root}}\label{secant_root}

\texttt{secant\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = secant\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map secant\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{second}}{second}}\label{second}

\texttt{second} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = second $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map second |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{second\_arg}}{second\_arg}}\label{second_arg}

\texttt{second\_arg} --- functional primitives builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = second\_arg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map second\_arg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{second\_elem}}{second\_elem}}\label{second_elem}

\texttt{second\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = second\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map second\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{second\_order\_concentration}}{second\_order\_concentration}}\label{second_order_concentration}

\texttt{second\_order\_concentration} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = second\_order\_concentration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map second\_order\_concentration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{second\_order\_half\_life}}{second\_order\_half\_life}}\label{second_order_half_life}

\texttt{second\_order\_half\_life} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = second\_order\_half\_life $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map second\_order\_half\_life |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seconds\_to\_days}}{seconds\_to\_days}}\label{seconds_to_days}

\texttt{seconds\_to\_days} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seconds\_to\_days $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seconds\_to\_hours}}{seconds\_to\_hours}}\label{seconds_to_hours}

\texttt{seconds\_to\_hours} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seconds\_to\_hours $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seconds\_to\_minutes}}{seconds\_to\_minutes}}\label{seconds_to_minutes}

\texttt{seconds\_to\_minutes} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seconds\_to\_minutes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{secp256k1\_y\_recover}}{secp256k1\_y\_recover}}\label{secp256k1_y_recover}

\texttt{secp256k1\_y\_recover} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = secp256k1\_y\_recover $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map secp256k1\_y\_recover |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sectarea}}{sectarea}}\label{sectarea}

\texttt{sectarea} --- geometry (extended) builtin. Alias for
\texttt{sector\_area}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sectarea $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sectarea |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sectional\_curvature\_two\_plane}}{sectional\_curvature\_two\_plane}}\label{sectional_curvature_two_plane}

\texttt{sectional\_curvature\_two\_plane} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sectional\_curvature\_two\_plane $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sectional\_curvature\_two\_plane |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sector\_area}}{sector\_area}}\label{sector_area}

\texttt{sector\_area(\$radius,\ \$theta)} --- computes the area of a
circular sector. Theta is the central angle in radians. Returns
\texttt{0.5\ *\ r²\ *\ theta}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sector\_area(10, 3.14159)   \# \textasciitilde{}157 (half circle)}
\NormalTok{p sector\_area(5, 1.57)       \# \textasciitilde{}19.6}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seg\_sum}}{seg\_sum}}\label{seg_sum}

\texttt{seg\_sum} --- batch 10 builtin. Alias for
\texttt{segment\_tree\_sum}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seg\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seg\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{segment\_distance\_point}}{segment\_distance\_point}}\label{segment_distance_point}

\texttt{segment\_distance\_point} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = segment\_distance\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map segment\_distance\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{segment\_intersection}}{segment\_intersection}}\label{segment_intersection}

\texttt{segment\_intersection} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = segment\_intersection $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map segment\_intersection |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{segment\_length}}{segment\_length}}\label{segment_length}

\texttt{segment\_length} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = segment\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map segment\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{segment\_tree\_sum}}{segment\_tree\_sum}}\label{segment_tree_sum}

\texttt{segment\_tree\_sum} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = segment\_tree\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map segment\_tree\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{segments\_parallel\_q}}{segments\_parallel\_q}}\label{segments_parallel_q}

\texttt{segments\_parallel\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = segments\_parallel\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map segments\_parallel\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{segments\_perpendicular\_q}}{segments\_perpendicular\_q}}\label{segments_perpendicular_q}

\texttt{segments\_perpendicular\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = segments\_perpendicular\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map segments\_perpendicular\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sei\_resistance\_growth}}{sei\_resistance\_growth}}\label{sei_resistance_growth}

\texttt{sei\_resistance\_growth} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sei\_resistance\_growth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sei\_resistance\_growth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seiberg\_witten\_value}}{seiberg\_witten\_value}}\label{seiberg_witten_value}

\texttt{seiberg\_witten\_value} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seiberg\_witten\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seiberg\_witten\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seifert\_form\_2x2}}{seifert\_form\_2x2}}\label{seifert_form_2x2}

\texttt{seifert\_form\_2x2} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seifert\_form\_2x2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seifert\_form\_2x2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seifert\_genus\_lower}}{seifert\_genus\_lower}}\label{seifert_genus_lower}

\texttt{seifert\_genus\_lower} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seifert\_genus\_lower $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seifert\_genus\_lower |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seir\_step}}{seir\_step}}\label{seir_step}

\texttt{seir\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seir\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seir\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seird\_step}}{seird\_step}}\label{seird_step}

\texttt{seird\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seird\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seird\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seirs\_step}}{seirs\_step}}\label{seirs_step}

\texttt{seirs\_step} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seirs\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seirs\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{select\_period\_step}}{select\_period\_step}}\label{select_period_step}

\texttt{select\_period\_step} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = select\_period\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map select\_period\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{select\_ultimate}}{select\_ultimate}}\label{select_ultimate}

\texttt{select\_ultimate} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = select\_ultimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map select\_ultimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{selection\_step}}{selection\_step}}\label{selection_step}

\texttt{selection\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = selection\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map selection\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{selu}}{selu}}\label{selu}

\texttt{selu} applies the Scaled ELU with fixed lambda=1.0507,
alpha=1.6733 for self-normalizing networks.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p selu(1)    \# 1.0507}
\NormalTok{p selu({-}1)   \# {-}1.1113}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{semctl}}{semctl}}\label{semctl}

\texttt{semctl} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = semctl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map semctl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{semget}}{semget}}\label{semget}

\texttt{semget} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = semget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map semget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{semi\_major\_axis}}{semi\_major\_axis}}\label{semi_major_axis}

\texttt{semi\_major\_axis} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = semi\_major\_axis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map semi\_major\_axis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{semop}}{semop}}\label{semop}

\texttt{semop} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = semop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map semop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sentence\_case}}{sentence\_case}}\label{sentence_case}

\texttt{sentence\_case} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sentence\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sentence\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seq}}{seq}}\label{seq}

\texttt{seq} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seq\_fn}}{seq\_fn}}\label{seq_fn}

\texttt{seq\_fn} --- generate a numeric sequence from, to, by. Like
R\textquotesingle s seq().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @s = @\{seq\_fn(1, 10, 2)\}  \# [1,3,5,7,9]}
\NormalTok{my @r = @\{seq\_fn(5, 1, {-}1)\}  \# [5,4,3,2,1]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seq\_logo\_information}}{seq\_logo\_information}}\label{seq_logo_information}

\texttt{seq\_logo\_information} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seq\_logo\_information $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seq\_logo\_information |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sequence\_shannon\_info}}{sequence\_shannon\_info}}\label{sequence_shannon_info}

\texttt{sequence\_shannon\_info} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sequence\_shannon\_info $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sequence\_shannon\_info |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sequent\_left\_intro}}{sequent\_left\_intro}}\label{sequent_left_intro}

\texttt{sequent\_left\_intro} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sequent\_left\_intro $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sequent\_left\_intro |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sequent\_right\_intro}}{sequent\_right\_intro}}\label{sequent_right_intro}

\texttt{sequent\_right\_intro} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sequent\_right\_intro $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sequent\_right\_intro |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sequential\_eq\_check}}{sequential\_eq\_check}}\label{sequential_eq_check}

\texttt{sequential\_eq\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sequential\_eq\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sequential\_eq\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{servo\_position\_velocity}}{servo\_position\_velocity}}\label{servo_position_velocity}

\texttt{servo\_position\_velocity} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = servo\_position\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map servo\_position\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{servo\_torque\_step}}{servo\_torque\_step}}\label{servo_torque_step}

\texttt{servo\_torque\_step} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = servo\_torque\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map servo\_torque\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{set\_at}}{set\_at}}\label{set_at}

\texttt{set\_at} --- batch 9 builtin. Alias for
\texttt{replace\_at\_index}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = set\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map set\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{set\_cover\_greedy\_step}}{set\_cover\_greedy\_step}}\label{set_cover_greedy_step}

\texttt{set\_cover\_greedy\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = set\_cover\_greedy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map set\_cover\_greedy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{set\_cover\_lp\_round}}{set\_cover\_lp\_round}}\label{set_cover_lp_round}

\texttt{set\_cover\_lp\_round} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = set\_cover\_lp\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map set\_cover\_lp\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{set\_subname}}{set\_subname}}\label{set_subname}

\texttt{set\_subname} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = set\_subname $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map set\_subname |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setex}}{setex}}\label{setex}

\texttt{setex} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setgrent}}{setgrent}}\label{setgrent}

\texttt{setgrent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setgrent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setgrent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sethostent}}{sethostent}}\label{sethostent}

\texttt{sethostent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sethostent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sethostent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setnetent}}{setnetent}}\label{setnetent}

\texttt{setnetent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setnetent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setnetent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setnx}}{setnx}}\label{setnx}

\texttt{setnx} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setnx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setnx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setprotoent}}{setprotoent}}\label{setprotoent}

\texttt{setprotoent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setprotoent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setprotoent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setpwent}}{setpwent}}\label{setpwent}

\texttt{setpwent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setpwent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setpwent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setrange}}{setrange}}\label{setrange}

\texttt{setrange} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setrange $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setrange |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{setservent}}{setservent}}\label{setservent}

\texttt{setservent} --- posix metadata builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = setservent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map setservent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{seven\_smooth\_q}}{seven\_smooth\_q}}\label{seven_smooth_q}

\texttt{seven\_smooth\_q} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = seven\_smooth\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map seven\_smooth\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sfork}}{sfork}}\label{sfork}

\texttt{sfork} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_fork}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sfork $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sfork |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sgemm}}{sgemm}}\label{sgemm}

\texttt{sgemm} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sgemm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sgemm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sgemv}}{sgemv}}\label{sgemv}

\texttt{sgemv} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sgemv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sgemv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sgnum}}{sgnum}}\label{sgnum}

\texttt{sgnum} --- extended stdlib builtin. Alias for
\texttt{signum\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sgnum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sgnum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sgp4\_propagate\_step}}{sgp4\_propagate\_step}}\label{sgp4_propagate_step}

\texttt{sgp4\_propagate\_step} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sgp4\_propagate\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sgp4\_propagate\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shake\_map\_pga}}{shake\_map\_pga}}\label{shake_map_pga}

\texttt{shake\_map\_pga} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shake\_map\_pga $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shake\_map\_pga |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shanks\_transform}}{shanks\_transform}}\label{shanks_transform}

\texttt{shanks\_transform} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shanks\_transform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shanks\_transform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shannon\_fano\_elias\_code}}{shannon\_fano\_elias\_code}}\label{shannon_fano_elias_code}

\texttt{shannon\_fano\_elias\_code} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shannon\_fano\_elias\_code $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shannon\_fano\_elias\_code |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shape\_operator\_eig}}{shape\_operator\_eig}}\label{shape_operator_eig}

\texttt{shape\_operator\_eig} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shape\_operator\_eig $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shape\_operator\_eig |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shapiro}}{shapiro}}\label{shapiro}

\texttt{shapiro\_test} (alias \texttt{shapiro}) --- Shapiro-Wilk
normality test. Returns W statistic (close to 1 = normal). Like
R\textquotesingle s shapiro.test().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p shapiro([rnorm(100)])  \# W ≈ 0.99 for normal data}
\NormalTok{p shapiro([1,1,1,2,10]) \# W \textless{} 0.9 for non{-}normal}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shapiro\_delay}}{shapiro\_delay}}\label{shapiro_delay}

\texttt{shapiro\_delay} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shapiro\_delay $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shapiro\_delay |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shapiro\_delay\_step}}{shapiro\_delay\_step}}\label{shapiro_delay_step}

\texttt{shapiro\_delay\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shapiro\_delay\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shapiro\_delay\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shapiro\_wilk}}{shapiro\_wilk}}\label{shapiro_wilk}

\texttt{shapiro\_wilk} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shapiro\_wilk $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shapiro\_wilk |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shapley\_value\_two\_step}}{shapley\_value\_two\_step}}\label{shapley_value_two_step}

\texttt{shapley\_value\_two\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shapley\_value\_two\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shapley\_value\_two\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sharpe}}{sharpe}}\label{sharpe}

\texttt{sharpe\_ratio(\textbackslash{}@returns,\ \$risk\_free\_rate)}
(alias \texttt{sharpe}) --- computes the Sharpe ratio measuring
risk-adjusted returns. Higher is better. Returns (mean\_return - rf) /
stddev.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @returns = (0.05, {-}0.02, 0.08, 0.03)}
\NormalTok{p sharpe(\textbackslash{}@returns, 0.02)   \# risk{-}adjusted performance}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sharpe\_annualized}}{sharpe\_annualized}}\label{sharpe_annualized}

\texttt{sharpe\_annualized} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sharpe\_annualized $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sharpe\_annualized |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sharpen\_kernel}}{sharpen\_kernel}}\label{sharpen_kernel}

\texttt{sharpen\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sharpen\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sharpen\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shear\_tensor\_step}}{shear\_tensor\_step}}\label{shear_tensor_step}

\texttt{shear\_tensor\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shear\_tensor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shear\_tensor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shepherd\_voltage\_step}}{shepherd\_voltage\_step}}\label{shepherd_voltage_step}

\texttt{shepherd\_voltage\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shepherd\_voltage\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shepherd\_voltage\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sherwood\_number\_step}}{sherwood\_number\_step}}\label{sherwood_number_step}

\texttt{sherwood\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sherwood\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sherwood\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shi\_tomasi\_corners}}{shi\_tomasi\_corners}}\label{shi_tomasi_corners}

\texttt{shi\_tomasi\_corners} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shi\_tomasi\_corners $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shi\_tomasi\_corners |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shift\_left}}{shift\_left}}\label{shift_left}

\texttt{shift\_left} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shift\_left $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shift\_left |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shift\_right}}{shift\_right}}\label{shift_right}

\texttt{shift\_right} --- bit ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shift\_right $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shift\_right |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shl}}{shl}}\label{shl}

\texttt{shl} --- bit ops builtin. Alias for \texttt{shift\_left}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shmctl}}{shmctl}}\label{shmctl}

\texttt{shmctl} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shmctl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shmctl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shmget}}{shmget}}\label{shmget}

\texttt{shmget} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shmget $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shmget |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shmread}}{shmread}}\label{shmread}

\texttt{shmread} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shmread $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shmread |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shmwrite}}{shmwrite}}\label{shmwrite}

\texttt{shmwrite} --- sysv ipc builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shmwrite $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shmwrite |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shoelace\_area}}{shoelace\_area}}\label{shoelace_area}

\texttt{shoelace\_area} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shoelace\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shoelace\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shooting\_pct}}{shooting\_pct}}\label{shooting_pct}

\texttt{shooting\_pct} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shooting\_pct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shooting\_pct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shor\_period}}{shor\_period}}\label{shor_period}

\texttt{shor\_period} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shor\_period $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shor\_period |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shor\_period\_prob}}{shor\_period\_prob}}\label{shor_period_prob}

\texttt{shor\_period\_prob} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shor\_period\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shor\_period\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{short\_id}}{short\_id}}\label{short_id}

\texttt{short\_id} --- id helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = short\_id $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map short\_id |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shorten}}{shorten}}\label{shorten}

\texttt{shorten} --- trivial string ops builtin. Alias for
\texttt{truncate\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shorten $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shorten |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shortest}}{shortest}}\label{shortest}

\texttt{shortest} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shortest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shortest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shortest\_path\_bfs}}{shortest\_path\_bfs}}\label{shortest_path_bfs}

\texttt{shortest\_path\_bfs} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shortest\_path\_bfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shortest\_path\_bfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shr}}{shr}}\label{shr}

\texttt{shr} --- bit ops builtin. Alias for \texttt{shift\_right}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shuf}}{shuf}}\label{shuf}

\texttt{shuf} --- extended stdlib builtin. Alias for
\texttt{shuffle\_arr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shuf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shuf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shuffle\_arr}}{shuffle\_arr}}\label{shuffle_arr}

\texttt{shuffle\_arr} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shuffle\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shuffle\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shuffle\_chars}}{shuffle\_chars}}\label{shuffle_chars}

\texttt{shuffle\_chars} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shuffle\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shuffle\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shuffled}}{shuffled}}\label{shuffled}

\texttt{shuffled} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shuffled $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shuffled |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{shunting\_yard\_step}}{shunting\_yard\_step}}\label{shunting_yard_step}

\texttt{shunting\_yard\_step} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = shunting\_yard\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map shunting\_yard\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sidereal\_day\_period}}{sidereal\_day\_period}}\label{sidereal_day_period}

\texttt{sidereal\_day\_period} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sidereal\_day\_period $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sidereal\_day\_period |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{siera}}{siera}}\label{siera}

\texttt{siera} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = siera $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map siera |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sierp}}{sierp}}\label{sierp}

\texttt{sierp} --- algorithms / puzzles builtin. Alias for
\texttt{sierpinski}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sierp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sierp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sierpinski}}{sierpinski}}\label{sierpinski}

\texttt{sierpinski} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sierpinski $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sierpinski |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sieve}}{sieve}}\label{sieve}

\texttt{sieve} --- number theory / primes builtin. Alias for
\texttt{primes\_up\_to}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sieve $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sieve |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sift\_keypoints}}{sift\_keypoints}}\label{sift_keypoints}

\texttt{sift\_keypoints} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sift\_keypoints $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sift\_keypoints |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sigma8\_default}}{sigma8\_default}}\label{sigma8_default}

\texttt{sigma8\_default} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sigma8\_default $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sigma8\_default |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sigma\_crit}}{sigma\_crit}}\label{sigma_crit}

\texttt{sigma\_crit} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sigma\_crit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sigma\_crit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sigma\_sb}}{sigma\_sb}}\label{sigma_sb}

\texttt{sigma\_sb} --- physics constants builtin. Alias for
\texttt{stefan\_boltzmann\_constant}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sigma\_sb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sigma\_sb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sigmoid}}{sigmoid}}\label{sigmoid}

\texttt{sigmoid} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sigmoid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sigmoid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sigmoid\_grad}}{sigmoid\_grad}}\label{sigmoid_grad}

\texttt{sigmoid\_grad} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sigmoid\_grad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sigmoid\_grad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sign}}{sign}}\label{sign}

\texttt{sign} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sign $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sign |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{signal\_name}}{signal\_name}}\label{signal_name}

\texttt{signal\_name} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = signal\_name $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map signal\_name |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{signum}}{signum}}\label{signum}

\texttt{signum} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = signum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map signum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{signum\_of}}{signum\_of}}\label{signum_of}

\texttt{signum\_of} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = signum\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map signum\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{silicate\_classify}}{silicate\_classify}}\label{silicate_classify}

\texttt{silicate\_classify} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = silicate\_classify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map silicate\_classify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{silu}}{silu}}\label{silu}

\texttt{silu} (alias \texttt{swish}) applies SiLU/Swish: x·sigmoid(x).
Smooth approximation to ReLU.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p silu(1)    \# 0.7311}
\NormalTok{p swish({-}2)  \# {-}0.2384}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{silver}}{silver}}\label{silver}

\texttt{silver\_ratio} (alias \texttt{silver}) --- δS = 1 + √2 ≈ 2.414.
Related to Pell numbers.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p silver   \# 2.414213562373095}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sim}}{sim}}\label{sim}

\texttt{sim} --- extended stdlib builtin. Alias for \texttt{similarity}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{similarity}}{similarity}}\label{similarity}

\texttt{similarity} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{similarity\_function\_phi}}{similarity\_function\_phi}}\label{similarity_function_phi}

\texttt{similarity\_function\_phi} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = similarity\_function\_phi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map similarity\_function\_phi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simon\_round}}{simon\_round}}\label{simon_round}

\texttt{simon\_round} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simon\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simon\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simple\_interest}}{simple\_interest}}\label{simple_interest}

\texttt{simple\_interest} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simple\_interest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simple\_interest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simple\_interest\_compute}}{simple\_interest\_compute}}\label{simple_interest_compute}

\texttt{simple\_interest\_compute} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simple\_interest\_compute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simple\_interest\_compute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simplex\_volume\_3d}}{simplex\_volume\_3d}}\label{simplex_volume_3d}

\texttt{simplex\_volume\_3d} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simplex\_volume\_3d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simplex\_volume\_3d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simplex\_volume\_n}}{simplex\_volume\_n}}\label{simplex_volume_n}

\texttt{simplex\_volume\_n} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simplex\_volume\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simplex\_volume\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simplicial\_volume}}{simplicial\_volume}}\label{simplicial_volume}

\texttt{simplicial\_volume} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simplicial\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simplicial\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simply\_typed\_check}}{simply\_typed\_check}}\label{simply_typed_check}

\texttt{simply\_typed\_check} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simply\_typed\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simply\_typed\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simps}}{simps}}\label{simps}

\texttt{simpson} (alias \texttt{simps}) integrates evenly-spaced samples
using Simpson\textquotesingle s rule. More accurate than trapz for
smooth functions.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @y = map \{ sin(\_ * 0.01) \} 0:314}
\NormalTok{p simps(\textbackslash{}@y, 0.01)  \# ≈ 2.0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simpson\_rule}}{simpson\_rule}}\label{simpson_rule}

\texttt{simpson\_rule} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simpson\_rule $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simpson\_rule |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simrank}}{simrank}}\label{simrank}

\texttt{simrank} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simrank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simrank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{simulated\_annealing\_step}}{simulated\_annealing\_step}}\label{simulated_annealing_step}

\texttt{simulated\_annealing\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = simulated\_annealing\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map simulated\_annealing\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sinc}}{sinc}}\label{sinc}

\texttt{sinc} returns the unnormalized sinc function: sin(x)/x, with
sinc(0)=1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sinc(0)       \# 1.0}
\NormalTok{p sinc(3.14159) \# ≈ 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sine\_integral\_si}}{sine\_integral\_si}}\label{sine_integral_si}

\texttt{sine\_integral\_si} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sine\_integral\_si $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sine\_integral\_si |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{single\_quote}}{single\_quote}}\label{single_quote}

\texttt{single\_quote} --- string quote / escape builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = single\_quote $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map single\_quote |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{single\_slit\_min}}{single\_slit\_min}}\label{single_slit_min}

\texttt{single\_slit\_min} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = single\_slit\_min $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map single\_slit\_min |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{single\_transferable\_vote}}{single\_transferable\_vote}}\label{single_transferable_vote}

\texttt{single\_transferable\_vote} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = single\_transferable\_vote $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map single\_transferable\_vote |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{singularity\_check\_2link}}{singularity\_check\_2link}}\label{singularity_check_2link}

\texttt{singularity\_check\_2link} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = singularity\_check\_2link $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map singularity\_check\_2link |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{singularize}}{singularize}}\label{singularize}

\texttt{singularize} --- batch 9 builtin. Alias for
\texttt{singularize\_simple}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = singularize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map singularize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{singularize\_simple}}{singularize\_simple}}\label{singularize_simple}

\texttt{singularize\_simple} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = singularize\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map singularize\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sinh}}{sinh}}\label{sinh}

\texttt{sinh} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sinh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sinh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sinhc}}{sinhc}}\label{sinhc}

\texttt{sinhc} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sinhc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sinhc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sinkhorn\_iteration\_step}}{sinkhorn\_iteration\_step}}\label{sinkhorn_iteration_step}

\texttt{sinkhorn\_iteration\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sinkhorn\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sinkhorn\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sinter}}{sinter}}\label{sinter}

\texttt{sinter} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sinter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sinter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sinusoidal\_project}}{sinusoidal\_project}}\label{sinusoidal_project}

\texttt{sinusoidal\_project} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sinusoidal\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sinusoidal\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{siphash24}}{siphash24}}\label{siphash24}

\texttt{siphash24} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = siphash24 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map siphash24 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{siphash\_keyed}}{siphash\_keyed}}\label{siphash_keyed}

\texttt{siphash\_keyed} 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p siphash\_keyed("data", 0x123456789, 0xabcdef012)  \# keyed hash}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sirs\_step}}{sirs\_step}}\label{sirs_step}

\texttt{sirs\_step} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sirs\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sirs\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sis\_step}}{sis\_step}}\label{sis_step}

\texttt{sis\_step} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sis\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sis\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sismember}}{sismember}}\label{sismember}

\texttt{sismember} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sismember $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sismember |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{size}}{size}}\label{size}

\texttt{size} returns the byte size of a file on disk --- equivalent to
Perl\textquotesingle s \texttt{-s\ FILE} file test. With no arguments,
it operates on \texttt{\_}; with one argument, it stats the given path;
with multiple arguments (or a flattened list), it returns an array of
sizes. Paths that can\textquotesingle t be stat\textquotesingle d return
\texttt{undef}. This is a stryke extension that makes pipelines over
filenames concise.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p size "Cargo.toml"                   \# 2013}
\NormalTok{f |\textgreater{} map +\{ \_ =\textgreater{} size \} |\textgreater{} tj |\textgreater{} p   \# [\{name =\textgreater{} bytes\}, ...]}
\NormalTok{f |\textgreater{} filter \{ size \textgreater{} 1024 \} |\textgreater{} e p    \# files larger than 1 KiB}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sjson}}{sjson}}\label{sjson}

\texttt{sjson} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_json}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sjson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sjson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_adjusted\_rand}}{sk\_adjusted\_rand}}\label{sk_adjusted_rand}

\texttt{sk\_adjusted\_rand} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_adjusted\_rand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_adjusted\_rand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_agglomerative\_fit}}{sk\_agglomerative\_fit}}\label{sk_agglomerative_fit}

\texttt{sk\_agglomerative\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_agglomerative\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_agglomerative\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_bayes\_search}}{sk\_bayes\_search}}\label{sk_bayes_search}

\texttt{sk\_bayes\_search} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_bayes\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_bayes\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_calinski\_harabasz}}{sk\_calinski\_harabasz}}\label{sk_calinski_harabasz}

\texttt{sk\_calinski\_harabasz} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_calinski\_harabasz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_calinski\_harabasz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_count\_vectorize}}{sk\_count\_vectorize}}\label{sk_count_vectorize}

\texttt{sk\_count\_vectorize} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_count\_vectorize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_count\_vectorize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_cross\_val\_score}}{sk\_cross\_val\_score}}\label{sk_cross_val_score}

\texttt{sk\_cross\_val\_score} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_cross\_val\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_cross\_val\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_davies\_bouldin}}{sk\_davies\_bouldin}}\label{sk_davies_bouldin}

\texttt{sk\_davies\_bouldin} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_davies\_bouldin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_davies\_bouldin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_dbscan\_fit}}{sk\_dbscan\_fit}}\label{sk_dbscan_fit}

\texttt{sk\_dbscan\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_dbscan\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_dbscan\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_decision\_tree\_split}}{sk\_decision\_tree\_split}}\label{sk_decision_tree_split}

\texttt{sk\_decision\_tree\_split} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_decision\_tree\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_decision\_tree\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_doc2vec\_train}}{sk\_doc2vec\_train}}\label{sk_doc2vec_train}

\texttt{sk\_doc2vec\_train} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_doc2vec\_train $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_doc2vec\_train |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_gbt\_fit}}{sk\_gbt\_fit}}\label{sk_gbt_fit}

\texttt{sk\_gbt\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_gbt\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_gbt\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_grid\_search}}{sk\_grid\_search}}\label{sk_grid_search}

\texttt{sk\_grid\_search} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_grid\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_grid\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_isolation\_forest\_fit}}{sk\_isolation\_forest\_fit}}\label{sk_isolation_forest_fit}

\texttt{sk\_isolation\_forest\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_isolation\_forest\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_isolation\_forest\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_kfold\_split}}{sk\_kfold\_split}}\label{sk_kfold_split}

\texttt{sk\_kfold\_split} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_kfold\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_kfold\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_kmeans\_fit}}{sk\_kmeans\_fit}}\label{sk_kmeans_fit}

\texttt{sk\_kmeans\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_kmeans\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_kmeans\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_knn\_predict}}{sk\_knn\_predict}}\label{sk_knn_predict}

\texttt{sk\_knn\_predict} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_knn\_predict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_knn\_predict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_label\_encode}}{sk\_label\_encode}}\label{sk_label_encode}

\texttt{sk\_label\_encode} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_label\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_label\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_lda\_topic}}{sk\_lda\_topic}}\label{sk_lda_topic}

\texttt{sk\_lda\_topic} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_lda\_topic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_lda\_topic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_lightgbm\_fit}}{sk\_lightgbm\_fit}}\label{sk_lightgbm_fit}

\texttt{sk\_lightgbm\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_lightgbm\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_lightgbm\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_lof\_fit}}{sk\_lof\_fit}}\label{sk_lof_fit}

\texttt{sk\_lof\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_lof\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_lof\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_logistic\_fit}}{sk\_logistic\_fit}}\label{sk_logistic_fit}

\texttt{sk\_logistic\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_logistic\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_logistic\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_logistic\_predict}}{sk\_logistic\_predict}}\label{sk_logistic_predict}

\texttt{sk\_logistic\_predict} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_logistic\_predict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_logistic\_predict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_min\_max\_scaler}}{sk\_min\_max\_scaler}}\label{sk_min_max_scaler}

\texttt{sk\_min\_max\_scaler} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_min\_max\_scaler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_min\_max\_scaler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_mutual\_info}}{sk\_mutual\_info}}\label{sk_mutual_info}

\texttt{sk\_mutual\_info} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_mutual\_info $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_mutual\_info |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_naive\_bayes\_predict}}{sk\_naive\_bayes\_predict}}\label{sk_naive_bayes_predict}

\texttt{sk\_naive\_bayes\_predict} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_naive\_bayes\_predict $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_naive\_bayes\_predict |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_nmf\_topic}}{sk\_nmf\_topic}}\label{sk_nmf_topic}

\texttt{sk\_nmf\_topic} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_nmf\_topic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_nmf\_topic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_one\_hot}}{sk\_one\_hot}}\label{sk_one_hot}

\texttt{sk\_one\_hot} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_one\_hot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_one\_hot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_ordinal\_encode}}{sk\_ordinal\_encode}}\label{sk_ordinal_encode}

\texttt{sk\_ordinal\_encode} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_ordinal\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_ordinal\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_pca\_fit}}{sk\_pca\_fit}}\label{sk_pca_fit}

\texttt{sk\_pca\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_pca\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_pca\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_pipeline\_fit}}{sk\_pipeline\_fit}}\label{sk_pipeline_fit}

\texttt{sk\_pipeline\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_pipeline\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_pipeline\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_power\_transform}}{sk\_power\_transform}}\label{sk_power_transform}

\texttt{sk\_power\_transform} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_power\_transform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_power\_transform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_quantile\_transform}}{sk\_quantile\_transform}}\label{sk_quantile_transform}

\texttt{sk\_quantile\_transform} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_quantile\_transform $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_quantile\_transform |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_random\_forest\_fit}}{sk\_random\_forest\_fit}}\label{sk_random_forest_fit}

\texttt{sk\_random\_forest\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_random\_forest\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_random\_forest\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_random\_search}}{sk\_random\_search}}\label{sk_random_search}

\texttt{sk\_random\_search} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_random\_search $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_random\_search |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_robust\_scaler}}{sk\_robust\_scaler}}\label{sk_robust_scaler}

\texttt{sk\_robust\_scaler} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_robust\_scaler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_robust\_scaler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_silhouette}}{sk\_silhouette}}\label{sk_silhouette}

\texttt{sk\_silhouette} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_silhouette $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_silhouette |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_standard\_scaler}}{sk\_standard\_scaler}}\label{sk_standard_scaler}

\texttt{sk\_standard\_scaler} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_standard\_scaler $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_standard\_scaler |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_stratified\_kfold}}{sk\_stratified\_kfold}}\label{sk_stratified_kfold}

\texttt{sk\_stratified\_kfold} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_stratified\_kfold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_stratified\_kfold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_svm\_fit}}{sk\_svm\_fit}}\label{sk_svm_fit}

\texttt{sk\_svm\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_svm\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_svm\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_tfidf}}{sk\_tfidf}}\label{sk_tfidf}

\texttt{sk\_tfidf} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_tfidf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_tfidf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_tsne\_fit}}{sk\_tsne\_fit}}\label{sk_tsne_fit}

\texttt{sk\_tsne\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_tsne\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_tsne\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_umap\_fit}}{sk\_umap\_fit}}\label{sk_umap_fit}

\texttt{sk\_umap\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_umap\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_umap\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_word2vec\_train}}{sk\_word2vec\_train}}\label{sk_word2vec_train}

\texttt{sk\_word2vec\_train} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_word2vec\_train $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_word2vec\_train |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sk\_xgb\_fit}}{sk\_xgb\_fit}}\label{sk_xgb_fit}

\texttt{sk\_xgb\_fit} --- batch 79 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sk\_xgb\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sk\_xgb\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skew}}{skew}}\label{skew}

\texttt{skew} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{skewness}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = skew $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map skew |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skewness}}{skewness}}\label{skewness}

\texttt{skewness} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = skewness $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map skewness |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skill\_score}}{skill\_score}}\label{skill_score}

\texttt{skill\_score} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = skill\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map skill\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skin\_depth}}{skin\_depth}}\label{skin_depth}

\texttt{skin\_depth} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = skin\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map skin\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skip\_assert}}{skip\_assert}}\label{skip_assert}

\texttt{skip\_assert} --- testing framework builtin. Alias for
\texttt{test\_skip}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = skip\_assert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map skip\_assert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skip\_test}}{skip\_test}}\label{skip_test}

\texttt{skip\_test} --- testing framework builtin. Alias for
\texttt{test\_skip}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = skip\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map skip\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{skip\_while}}{skip\_while}}\label{skip_while}

\texttt{skip\_while\ \{\ COND\ \}\ LIST} --- skip leading elements while
the predicate is true (alias for \texttt{drop\_while}).

Behavior is identical to \texttt{drop\_while}: once the predicate
returns false, that element and all subsequent elements are emitted. The
\texttt{skip\_while} name is provided for users coming from Rust or
Kotlin where this is the conventional name. Both compile to the same
streaming operation internally.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{1:10 |\textgreater{} skip\_while \{ \_ \textless{} 5 \} |\textgreater{} e p \# 5 6 7 8 9 10}
\NormalTok{@sorted |\textgreater{} skip\_while \{ \_ le "m" \} |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sla}}{sla}}\label{sla}

\texttt{sla} --- python/ruby stdlib builtin. Alias for
\texttt{slice\_arr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sla $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sla |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slca}}{slca}}\label{slca}

\texttt{slca} --- additional missing stdlib functions builtin. Alias for
\texttt{slice\_after}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slca $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slca |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slcb}}{slcb}}\label{slcb}

\texttt{slcb} --- additional missing stdlib functions builtin. Alias for
\texttt{slice\_before}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slcb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slcb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slcw}}{slcw}}\label{slcw}

\texttt{slcw} --- additional missing stdlib functions builtin. Alias for
\texttt{slice\_when}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slcw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slcw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slic\_superpixels}}{slic\_superpixels}}\label{slic_superpixels}

\texttt{slic\_superpixels} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slic\_superpixels $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slic\_superpixels |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slice\_after}}{slice\_after}}\label{slice_after}

\texttt{slice\_after} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slice\_after $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slice\_after |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slice\_arr}}{slice\_arr}}\label{slice_arr}

\texttt{slice\_arr} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slice\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slice\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slice\_before}}{slice\_before}}\label{slice_before}

\texttt{slice\_before} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slice\_before $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slice\_before |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slice\_when}}{slice\_when}}\label{slice_when}

\texttt{slice\_when} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slice\_when $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slice\_when |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sliced\_wasserstein}}{sliced\_wasserstein}}\label{sliced_wasserstein}

\texttt{sliced\_wasserstein} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sliced\_wasserstein $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sliced\_wasserstein |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sliding\_pairs}}{sliding\_pairs}}\label{sliding_pairs}

\texttt{sliding\_pairs} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sliding\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sliding\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sliding\_window}}{sliding\_window}}\label{sliding_window}

\texttt{sliding\_window} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sliding\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sliding\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slope}}{slope}}\label{slope}

\texttt{slope} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slope $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slope |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slug}}{slug}}\label{slug}

\texttt{slug} --- extended stdlib builtin. Alias for \texttt{slugify}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slug $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slug |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slugify}}{slugify}}\label{slugify}

\texttt{slugify} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slugify $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slugify |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{slutsky\_decompose}}{slutsky\_decompose}}\label{slutsky_decompose}

\texttt{slutsky\_decompose} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = slutsky\_decompose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map slutsky\_decompose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smap}}{smap}}\label{smap}

\texttt{smap} --- python/ruby stdlib builtin. Alias for
\texttt{starmap}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smembers}}{smembers}}\label{smembers}

\texttt{smembers} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smembers $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smembers |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smith\_normal\_2x2\_step}}{smith\_normal\_2x2\_step}}\label{smith_normal_2x2_step}

\texttt{smith\_normal\_2x2\_step} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smith\_normal\_2x2\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smith\_normal\_2x2\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smith\_predictor\_step}}{smith\_predictor\_step}}\label{smith_predictor_step}

\texttt{smith\_predictor\_step} --- batch 59 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smith\_predictor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smith\_predictor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smith\_q}}{smith\_q}}\label{smith_q}

\texttt{smith\_q} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smith\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smith\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smith\_waterman\_score}}{smith\_waterman\_score}}\label{smith_waterman_score}

\texttt{smith\_waterman\_score} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smith\_waterman\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smith\_waterman\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smmap}}{smmap}}\label{smmap}

\texttt{smmap} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_mmap}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smoothstep}}{smoothstep}}\label{smoothstep}

\texttt{smoothstep(\$edge0,\ \$edge1,\ \$x)} --- smooth Hermite
interpolation. Returns 0 if x ≤ edge0, 1 if x ≥ edge1, otherwise smooth
S-curve. Great for animations.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p smoothstep(0, 1, 0.5)   \# 0.5 (but with smooth acceleration/deceleration)}
\NormalTok{p smoothstep(10, 20, 15)  \# 0.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smst}}{smst}}\label{smst}

\texttt{smst} --- extended stdlib builtin. Alias for
\texttt{smoothstep}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smt\_qf\_lia\_solve\_step}}{smt\_qf\_lia\_solve\_step}}\label{smt_qf_lia_solve_step}

\texttt{smt\_qf\_lia\_solve\_step} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smt\_qf\_lia\_solve\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smt\_qf\_lia\_solve\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{smt\_qf\_uf\_combine}}{smt\_qf\_uf\_combine}}\label{smt_qf_uf_combine}

\texttt{smt\_qf\_uf\_combine} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = smt\_qf\_uf\_combine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map smt\_qf\_uf\_combine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snake\_to\_camel}}{snake\_to\_camel}}\label{snake_to_camel}

\texttt{snake\_to\_camel} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = snake\_to\_camel $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snappy\_encode}}{snappy\_encode}}\label{snappy_encode}

\texttt{snappy\_encode} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = snappy\_encode $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map snappy\_encode |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snd}}{snd}}\label{snd}

\texttt{snd} --- algebraic match builtin. Alias for \texttt{second}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = snd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map snd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snell}}{snell}}\label{snell}

\texttt{snells\_law(\$n1,\ \$n2,\ \$theta1)} (alias \texttt{snell}) ---
refraction angle using Snell\textquotesingle s law. Angles in degrees.
Returns undef for total internal reflection.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p snell(1, 1.5, 30)     \# \textasciitilde{}19.5° (air to glass)}
\NormalTok{p snell(1.5, 1, 45)     \# undef (total internal reflection)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snell\_theta2}}{snell\_theta2}}\label{snell_theta2}

\texttt{snell\_theta2} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = snell\_theta2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map snell\_theta2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snowball\_stem\_english}}{snowball\_stem\_english}}\label{snowball_stem_english}

\texttt{snowball\_stem\_english} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = snowball\_stem\_english $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map snowball\_stem\_english |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{snowball\_stem\_french}}{snowball\_stem\_french}}\label{snowball_stem_french}

\texttt{snowball\_stem\_french} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = snowball\_stem\_french $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map snowball\_stem\_french |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sobel\_diagonal\_kernel}}{sobel\_diagonal\_kernel}}\label{sobel_diagonal_kernel}

\texttt{sobel\_diagonal\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sobel\_diagonal\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sobel\_diagonal\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sobel\_kernel\_value}}{sobel\_kernel\_value}}\label{sobel_kernel_value}

\texttt{sobel\_kernel\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sobel\_kernel\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sobel\_kernel\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{soc\_estimate\_coulomb}}{soc\_estimate\_coulomb}}\label{soc_estimate_coulomb}

\texttt{soc\_estimate\_coulomb} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = soc\_estimate\_coulomb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map soc\_estimate\_coulomb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{social\_welfare\_nash}}{social\_welfare\_nash}}\label{social_welfare_nash}

\texttt{social\_welfare\_nash} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = social\_welfare\_nash $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map social\_welfare\_nash |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{social\_welfare\_rawls}}{social\_welfare\_rawls}}\label{social_welfare_rawls}

\texttt{social\_welfare\_rawls} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = social\_welfare\_rawls $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map social\_welfare\_rawls |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{social\_welfare\_sum}}{social\_welfare\_sum}}\label{social_welfare_sum}

\texttt{social\_welfare\_sum} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = social\_welfare\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map social\_welfare\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{social\_welfare\_utilitarian}}{social\_welfare\_utilitarian}}\label{social_welfare_utilitarian}

\texttt{social\_welfare\_utilitarian} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = social\_welfare\_utilitarian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map social\_welfare\_utilitarian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{socketpair}}{socketpair}}\label{socketpair}

\texttt{socketpair} --- socket builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = socketpair $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map socketpair |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sockets}}{sockets}}\label{sockets}

\texttt{sockets} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sockets $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sockets |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sod}}{sod}}\label{sod}

\texttt{sod} --- extended stdlib builtin. Alias for
\texttt{start\_of\_day}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sod $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sod |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{softmax}}{softmax}}\label{softmax}

\texttt{softmax} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = softmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map softmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{softplus}}{softplus}}\label{softplus}

\texttt{softplus} applies the Softplus activation: ln(1 + e\^{}x).
Smooth approximation to ReLU.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p softplus(0)   \# 0.6931 (ln 2)}
\NormalTok{p softplus(10)  \# ≈ 10}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{softsign}}{softsign}}\label{softsign}

\texttt{softsign} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = softsign $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map softsign |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{soh}}{soh}}\label{soh}

\texttt{soh} --- extended stdlib builtin. Alias for
\texttt{start\_of\_hour}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = soh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map soh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{soh\_capacity\_fade}}{soh\_capacity\_fade}}\label{soh_capacity_fade}

\texttt{soh\_capacity\_fade} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = soh\_capacity\_fade $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map soh\_capacity\_fade |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{soi\_oscillation\_index}}{soi\_oscillation\_index}}\label{soi_oscillation_index}

\texttt{soi\_oscillation\_index} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = soi\_oscillation\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map soi\_oscillation\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sol}}{sol}}\label{sol}

\texttt{sol} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_constant}}{solar\_constant}}\label{solar_constant}

\texttt{solar\_constant} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solar\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_constant\_at\_distance}}{solar\_constant\_at\_distance}}\label{solar_constant_at_distance}

\texttt{solar\_constant\_at\_distance} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_constant\_at\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solar\_constant\_at\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_cycle\_phase}}{solar\_cycle\_phase}}\label{solar_cycle_phase}

\texttt{solar\_cycle\_phase} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_cycle\_phase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solar\_cycle\_phase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_declination}}{solar\_declination}}\label{solar_declination}

\texttt{solar\_declination} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_declination $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solar\_declination |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_luminosity\_to\_w}}{solar\_luminosity\_to\_w}}\label{solar_luminosity_to_w}

\texttt{solar\_luminosity\_to\_w} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_luminosity\_to\_w $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_mass\_to\_kg}}{solar\_mass\_to\_kg}}\label{solar_mass_to_kg}

\texttt{solar\_mass\_to\_kg} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_mass\_to\_kg $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solar\_zenith\_angle}}{solar\_zenith\_angle}}\label{solar_zenith_angle}

\texttt{solar\_zenith\_angle} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solar\_zenith\_angle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solar\_zenith\_angle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sole}}{sole}}\label{sole}

\texttt{sole} --- ruby enumerable extras builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sole $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sole |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solid\_electrolyte\_capacity}}{solid\_electrolyte\_capacity}}\label{solid_electrolyte_capacity}

\texttt{solid\_electrolyte\_capacity} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solid\_electrolyte\_capacity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solid\_electrolyte\_capacity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solstice\_winter}}{solstice\_winter}}\label{solstice_winter}

\texttt{solstice\_winter} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solstice\_winter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solstice\_winter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solution\_resistance\_estimate}}{solution\_resistance\_estimate}}\label{solution_resistance_estimate}

\texttt{solution\_resistance\_estimate} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solution\_resistance\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solution\_resistance\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solvable\_length\_upper}}{solvable\_length\_upper}}\label{solvable_length_upper}

\texttt{solvable\_length\_upper} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solvable\_length\_upper $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solvable\_length\_upper |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{solve\_ivp\_step}}{solve\_ivp\_step}}\label{solve_ivp_step}

\texttt{solve\_ivp\_step} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = solve\_ivp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map solve\_ivp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{som}}{som}}\label{som}

\texttt{som} --- extended stdlib builtin. Alias for
\texttt{start\_of\_minute}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = som $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map som |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{some}}{some}}\label{some}

\texttt{some} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = some $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map some |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sorensen\_dice}}{sorensen\_dice}}\label{sorensen_dice}

\texttt{sorensen\_dice} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sorensen\_dice $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sorensen\_dice |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sort\_by}}{sort\_by}}\label{sort_by}

\texttt{sort\_by} --- functional / iterator builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sort\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sort\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sort\_on}}{sort\_on}}\label{sort_on}

\texttt{sort\_on} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sort\_on $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sort\_on |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sort\_words}}{sort\_words}}\label{sort_words}

\texttt{sort\_words} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sort\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sort\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sorted}}{sorted}}\label{sorted}

\texttt{sorted} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sorted\_by\_length}}{sorted\_by\_length}}\label{sorted_by_length}

\texttt{sorted\_by\_length} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sorted\_by\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sorted\_by\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sorted\_desc}}{sorted\_desc}}\label{sorted_desc}

\texttt{sorted\_desc} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sorted\_desc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sorted\_desc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sorted\_nums}}{sorted\_nums}}\label{sorted_nums}

\texttt{sorted\_nums} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sorted\_nums $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sorted\_nums |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sortino}}{sortino}}\label{sortino}

\texttt{sortino\_ratio(\textbackslash{}@returns,\ \$target)} (alias
\texttt{sortino}) --- computes the Sortino ratio, similar to Sharpe but
only penalizes downside volatility. Better for asymmetric return
distributions.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @returns = (0.05, {-}0.02, 0.08, {-}0.01)}
\NormalTok{p sortino(\textbackslash{}@returns, 0.0)   \# penalizes only negative returns}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sortw}}{sortw}}\label{sortw}

\texttt{sortw} --- string processing (uncategorized batch) builtin.
Alias for \texttt{sort\_words}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sortw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sortw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sos2tf\_step}}{sos2tf\_step}}\label{sos2tf_step}

\texttt{sos2tf\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sos2tf\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sos2tf\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sos\_constraint\_check}}{sos\_constraint\_check}}\label{sos_constraint_check}

\texttt{sos\_constraint\_check} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sos\_constraint\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sos\_constraint\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sosfilt\_step}}{sosfilt\_step}}\label{sosfilt_step}

\texttt{sosfilt\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sosfilt\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sosfilt\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sound\_db}}{sound\_db}}\label{sound_db}

\texttt{sound\_db} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sound\_db $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sound\_db |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sound\_gas}}{sound\_gas}}\label{sound_gas}

\texttt{sound\_gas} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sound\_gas $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sound\_gas |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sound\_horizon\_recomb}}{sound\_horizon\_recomb}}\label{sound_horizon_recomb}

\texttt{sound\_horizon\_recomb} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sound\_horizon\_recomb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sound\_horizon\_recomb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sound\_solid}}{sound\_solid}}\label{sound_solid}

\texttt{sound\_solid} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sound\_solid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sound\_solid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{soundex}}{soundex}}\label{soundex}

\texttt{soundex} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = soundex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map soundex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{soundex\_phonetic}}{soundex\_phonetic}}\label{soundex_phonetic}

\texttt{soundex\_phonetic} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = soundex\_phonetic $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map soundex\_phonetic |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spaceship}}{spaceship}}\label{spaceship}

\texttt{spaceship} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spaceship $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spaceship |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{span}}{span}}\label{span}

\texttt{span} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = span $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map span |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{span\_fn}}{span\_fn}}\label{span_fn}

\texttt{span\_fn} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = span\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map span\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spanf}}{spanf}}\label{spanf}

\texttt{spanf} --- haskell list functions builtin. Alias for
\texttt{span\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spanf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spanf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sparse\_csr\_build}}{sparse\_csr\_build}}\label{sparse_csr_build}

\texttt{sparse\_csr\_build} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sparse\_csr\_build $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sparse\_csr\_build |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sparse\_csr\_mul\_vec}}{sparse\_csr\_mul\_vec}}\label{sparse_csr_mul_vec}

\texttt{sparse\_csr\_mul\_vec} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sparse\_csr\_mul\_vec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sparse\_csr\_mul\_vec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sparse\_density}}{sparse\_density}}\label{sparse_density}

\texttt{sparse\_density} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sparse\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sparse\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spat}}{spat}}\label{spat}

\texttt{spat} --- algebraic match builtin. Alias for \texttt{split\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spbfs}}{spbfs}}\label{spbfs}

\texttt{spbfs} --- extended stdlib builtin. Alias for
\texttt{shortest\_path\_bfs}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spbfs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spbfs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spearman}}{spearman}}\label{spearman}

\texttt{spearman\_correlation(\textbackslash{}@x,\ \textbackslash{}@y)}
(alias \texttt{spearman}) --- computes Spearman\textquotesingle s rank
correlation coefficient between two datasets. Measures monotonic
relationships, robust to outliers. Returns a value from -1 to 1.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @x = (1, 2, 3, 4, 5)}
\NormalTok{my @y = (5, 6, 7, 8, 7)}
\NormalTok{p spearman(\textbackslash{}@x, \textbackslash{}@y)   \# high positive correlation}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spearmanr}}{spearmanr}}\label{spearmanr}

\texttt{spearmanr} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spearmanr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spearmanr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{species\_area}}{species\_area}}\label{species_area}

\texttt{species\_area} --- batch 22 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = species\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map species\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{specific\_angular\_momentum}}{specific\_angular\_momentum}}\label{specific_angular_momentum}

\texttt{specific\_angular\_momentum} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = specific\_angular\_momentum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map specific\_angular\_momentum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{specific\_capacity\_active}}{specific\_capacity\_active}}\label{specific_capacity_active}

\texttt{specific\_capacity\_active} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = specific\_capacity\_active $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map specific\_capacity\_active |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{specific\_gravity\_water}}{specific\_gravity\_water}}\label{specific_gravity_water}

\texttt{specific\_gravity\_water} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = specific\_gravity\_water $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map specific\_gravity\_water |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{specific\_heat\_const\_v}}{specific\_heat\_const\_v}}\label{specific_heat_const_v}

\texttt{specific\_heat\_const\_v} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = specific\_heat\_const\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map specific\_heat\_const\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{specific\_orbital\_energy}}{specific\_orbital\_energy}}\label{specific_orbital_energy}

\texttt{specific\_orbital\_energy} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = specific\_orbital\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map specific\_orbital\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{specificity}}{specificity}}\label{specificity}

\texttt{specificity} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = specificity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map specificity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{speck\_round}}{speck\_round}}\label{speck_round}

\texttt{speck\_round} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = speck\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map speck\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectral\_density\_estimate}}{spectral\_density\_estimate}}\label{spectral_density_estimate}

\texttt{spectral\_density\_estimate} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectral\_density\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectral\_density\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectral\_kappa\_minus53}}{spectral\_kappa\_minus53}}\label{spectral_kappa_minus53}

\texttt{spectral\_kappa\_minus53} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectral\_kappa\_minus53 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectral\_kappa\_minus53 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectral\_radius}}{spectral\_radius}}\label{spectral_radius}

\texttt{spectral\_radius} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectral\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectral\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectral\_signature\_match}}{spectral\_signature\_match}}\label{spectral_signature_match}

\texttt{spectral\_signature\_match} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectral\_signature\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectral\_signature\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectro}}{spectro}}\label{spectro}

\texttt{spectro} --- dsp / signal (extended) builtin. Alias for
\texttt{spectrogram}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectro $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectro |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectrogram}}{spectrogram}}\label{spectrogram}

\texttt{spectrogram(\textbackslash{}@signal,\ \$window\_size,\ \$hop\_size)}
(alias \texttt{stft}) --- computes Short-Time Fourier Transform. Returns
a 2D arrayref where each row is the spectrum of a windowed segment.
Useful for time-frequency analysis.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $spec = stft(\textbackslash{}@audio, 1024, 512)}
\NormalTok{\# $spec{-}\textgreater{}[t][f] is magnitude at time t, frequency f}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectrogram\_simple}}{spectrogram\_simple}}\label{spectrogram_simple}

\texttt{spectrogram\_simple} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectrogram\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectrogram\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectrophotometer\_beer\_lambert}}{spectrophotometer\_beer\_lambert}}\label{spectrophotometer_beer_lambert}

\texttt{spectrophotometer\_beer\_lambert} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectrophotometer\_beer\_lambert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectrophotometer\_beer\_lambert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spectroscopic\_factor}}{spectroscopic\_factor}}\label{spectroscopic_factor}

\texttt{spectroscopic\_factor} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spectroscopic\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spectroscopic\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{speed\_distance\_time}}{speed\_distance\_time}}\label{speed_distance_time}

\texttt{speed\_distance\_time} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = speed\_distance\_time $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map speed\_distance\_time |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{speed\_of\_light}}{speed\_of\_light}}\label{speed_of_light}

\texttt{speed\_of\_light} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = speed\_of\_light $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map speed\_of\_light |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{speed\_of\_sound\_ideal}}{speed\_of\_sound\_ideal}}\label{speed_of_sound_ideal}

\texttt{speed\_of\_sound\_ideal} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = speed\_of\_sound\_ideal $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map speed\_of\_sound\_ideal |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spew}}{spew}}\label{spew}

\texttt{spew} --- filesystem extensions builtin. Alias for
\texttt{spurt}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spew $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spew |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sph\_harm}}{sph\_harm}}\label{sph_harm}

\texttt{sph\_harm} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sph\_harm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sph\_harm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sphenic\_q}}{sphenic\_q}}\label{sphenic_q}

\texttt{sphenic\_q} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sphenic\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sphenic\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sphere\_of\_influence}}{sphere\_of\_influence}}\label{sphere_of_influence}

\texttt{sphere\_of\_influence} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sphere\_of\_influence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sphere\_of\_influence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sphere\_surface}}{sphere\_surface}}\label{sphere_surface}

\texttt{sphere\_surface} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sphere\_surface $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sphere\_surface |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sphere\_volume}}{sphere\_volume}}\label{sphere_volume}

\texttt{sphere\_volume} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sphere\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sphere\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_bessel\_j0}}{spherical\_bessel\_j0}}\label{spherical_bessel_j0}

\texttt{spherical\_bessel\_j0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_bessel\_j0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_bessel\_j0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_bessel\_j1}}{spherical\_bessel\_j1}}\label{spherical_bessel_j1}

\texttt{spherical\_bessel\_j1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_bessel\_j1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_bessel\_j1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_bessel\_y0}}{spherical\_bessel\_y0}}\label{spherical_bessel_y0}

\texttt{spherical\_bessel\_y0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_bessel\_y0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_bessel\_y0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_bessel\_y1}}{spherical\_bessel\_y1}}\label{spherical_bessel_y1}

\texttt{spherical\_bessel\_y1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_bessel\_y1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_bessel\_y1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_jn}}{spherical\_jn}}\label{spherical_jn}

\texttt{spherical\_jn} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_jn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_jn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_triangle\_area}}{spherical\_triangle\_area}}\label{spherical_triangle_area}

\texttt{spherical\_triangle\_area} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_triangle\_area $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_triangle\_area |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spherical\_yn}}{spherical\_yn}}\label{spherical_yn}

\texttt{spherical\_yn} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spherical\_yn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spherical\_yn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sphsurf}}{sphsurf}}\label{sphsurf}

\texttt{sphsurf} --- geometry / physics builtin. Alias for
\texttt{sphere\_surface}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sphsurf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sphsurf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sphvol}}{sphvol}}\label{sphvol}

\texttt{sphvol} --- geometry / physics builtin. Alias for
\texttt{sphere\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sphvol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sphvol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spin\_casimir}}{spin\_casimir}}\label{spin_casimir}

\texttt{spin\_casimir} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spin\_casimir $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spin\_casimir |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spin\_orbit\_coupling\_term}}{spin\_orbit\_coupling\_term}}\label{spin_orbit_coupling_term}

\texttt{spin\_orbit\_coupling\_term} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spin\_orbit\_coupling\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spin\_orbit\_coupling\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spin\_spin\_coupling\_term}}{spin\_spin\_coupling\_term}}\label{spin_spin_coupling_term}

\texttt{spin\_spin\_coupling\_term} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spin\_spin\_coupling\_term $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spin\_spin\_coupling\_term |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spinner\_start}}{spinner\_start}}\label{spinner_start}

\texttt{spinner\_start} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spinner\_start $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spinner\_start |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spinner\_stop}}{spinner\_stop}}\label{spinner_stop}

\texttt{spinner\_stop} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spinner\_stop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spinner\_stop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{split\_at}}{split\_at}}\label{split_at}

\texttt{split\_at} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = split\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map split\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{split\_on}}{split\_on}}\label{split_on}

\texttt{split\_on} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = split\_on $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map split\_on |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{split\_regex}}{split\_regex}}\label{split_regex}

\texttt{split\_regex} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = split\_regex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map split\_regex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{split\_with}}{split\_with}}\label{split_with}

\texttt{split\_with} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = split\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map split\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{splitmix64\_step}}{splitmix64\_step}}\label{splitmix64_step}

\texttt{splitmix64\_step} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = splitmix64\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map splitmix64\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{splre}}{splre}}\label{splre}

\texttt{splre} --- extended stdlib builtin. Alias for
\texttt{split\_regex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = splre $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map splre |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spon}}{spon}}\label{spon}

\texttt{spon} --- go/general functional utilities builtin. Alias for
\texttt{split\_on}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spookyhash\_128}}{spookyhash\_128}}\label{spookyhash_128}

\texttt{spookyhash\_128} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spookyhash\_128 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spookyhash\_128 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spop}}{spop}}\label{spop}

\texttt{spop} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spop $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spop |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spring\_energy}}{spring\_energy}}\label{spring_energy}

\texttt{spring\_energy} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spring\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spring\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spring\_force}}{spring\_force}}\label{spring_force}

\texttt{spring\_force} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spring\_force $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spring\_force |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spring\_period}}{spring\_period}}\label{spring_period}

\texttt{spring\_period} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spring\_period $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spring\_period |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{springpe}}{springpe}}\label{springpe}

\texttt{springpe} --- physics formulas builtin. Alias for
\texttt{spring\_energy}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = springpe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map springpe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spt\_n\_correction}}{spt\_n\_correction}}\label{spt_n_correction}

\texttt{spt\_n\_correction} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spt\_n\_correction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spt\_n\_correction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{spw}}{spw}}\label{spw}

\texttt{spw} --- algebraic match builtin. Alias for
\texttt{split\_with}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = spw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map spw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sql}}{sql}}\label{sql}

\texttt{sql} --- data / network builtin. Alias for \texttt{sqlite}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sql $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sql |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sqr}}{sqr}}\label{sqr}

\texttt{sqr} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sqr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sqr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sqrt2}}{sqrt2}}\label{sqrt2}

\texttt{sqrt2} --- math / physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sqrt2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sqrt2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sqrt\_each}}{sqrt\_each}}\label{sqrt_each}

\texttt{sqrt\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sqrt\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sqrt\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sqrt\_swap\_gate}}{sqrt\_swap\_gate}}\label{sqrt_swap_gate}

\texttt{sqrt\_swap\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sqrt\_swap\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sqrt\_swap\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{square\_each}}{square\_each}}\label{square_each}

\texttt{square\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = square\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map square\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{square\_pyramidal\_number}}{square\_pyramidal\_number}}\label{square_pyramidal_number}

\texttt{square\_pyramidal\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = square\_pyramidal\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map square\_pyramidal\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{square\_root}}{square\_root}}\label{square_root}

\texttt{square\_root} --- math functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = square\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map square\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squared\_hinge}}{squared\_hinge}}\label{squared_hinge}

\texttt{squared\_hinge} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = squared\_hinge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map squared\_hinge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squared\_triangular}}{squared\_triangular}}\label{squared_triangular}

\texttt{squared\_triangular} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = squared\_triangular $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map squared\_triangular |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squares\_seq}}{squares\_seq}}\label{squares_seq}

\texttt{squares\_seq} --- sequences builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = squares\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map squares\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squeezing\_db}}{squeezing\_db}}\label{squeezing_db}

\texttt{squeezing\_db} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = squeezing\_db $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map squeezing\_db |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{squish}}{squish}}\label{squish}

\texttt{squish} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = squish $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map squish |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sregex}}{sregex}}\label{sregex}

\texttt{sregex} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_regex}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sregex $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sregex |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{srem}}{srem}}\label{srem}

\texttt{srem} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = srem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map srem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{srgb\_to\_xyz}}{srgb\_to\_xyz}}\label{srgb_to_xyz}

\texttt{srgb\_to\_xyz} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = srgb\_to\_xyz $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{srton}}{srton}}\label{srton}

\texttt{srton} --- haskell list functions builtin. Alias for
\texttt{sort\_on}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = srton $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map srton |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ssa\_phi\_insert}}{ssa\_phi\_insert}}\label{ssa_phi_insert}

\texttt{ssa\_phi\_insert} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ssa\_phi\_insert $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ssa\_phi\_insert |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ssn\_check}}{ssn\_check}}\label{ssn_check}

\texttt{ssn\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ssn\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ssn\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ssort}}{ssort}}\label{ssort}

\texttt{ssort} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_sort}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ssort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ssort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sst\_anomaly\_step}}{sst\_anomaly\_step}}\label{sst_anomaly_step}

\texttt{sst\_anomaly\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sst\_anomaly\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sst\_anomaly\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stable\_matching\_count}}{stable\_matching\_count}}\label{stable_matching_count}

\texttt{stable\_matching\_count} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stable\_matching\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stable\_matching\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stack\_new}}{stack\_new}}\label{stack_new}

\texttt{stack\_new} --- data structure helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stack\_new $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stack\_new |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stackelberg\_eq}}{stackelberg\_eq}}\label{stackelberg_eq}

\texttt{stackelberg\_eq} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stackelberg\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stackelberg\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stackelberg\_step}}{stackelberg\_step}}\label{stackelberg_step}

\texttt{stackelberg\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stackelberg\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stackelberg\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stag\_hunt\_payoff}}{stag\_hunt\_payoff}}\label{stag_hunt_payoff}

\texttt{stag\_hunt\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stag\_hunt\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stag\_hunt\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{standard\_error}}{standard\_error}}\label{standard_error}

\texttt{standard\_error} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = standard\_error $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map standard\_error |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{standardized\_mortality\_smr}}{standardized\_mortality\_smr}}\label{standardized_mortality_smr}

\texttt{standardized\_mortality\_smr} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = standardized\_mortality\_smr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map standardized\_mortality\_smr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{standing\_wave\_fundamental}}{standing\_wave\_fundamental}}\label{standing_wave_fundamental}

\texttt{standing\_wave\_fundamental} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = standing\_wave\_fundamental $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map standing\_wave\_fundamental |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{star\_number}}{star\_number}}\label{star_number}

\texttt{star\_number} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = star\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map star\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stark\_shift\_linear}}{stark\_shift\_linear}}\label{stark_shift_linear}

\texttt{stark\_shift\_linear} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stark\_shift\_linear $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stark\_shift\_linear |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{starmap}}{starmap}}\label{starmap}

\texttt{starmap} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = starmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map starmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{start\_of\_day}}{start\_of\_day}}\label{start_of_day}

\texttt{start\_of\_day} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = start\_of\_day $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map start\_of\_day |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{start\_of\_hour}}{start\_of\_hour}}\label{start_of_hour}

\texttt{start\_of\_hour} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = start\_of\_hour $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map start\_of\_hour |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{start\_of\_minute}}{start\_of\_minute}}\label{start_of_minute}

\texttt{start\_of\_minute} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = start\_of\_minute $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map start\_of\_minute |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{starts\_with}}{starts\_with}}\label{starts_with}

\texttt{starts\_with} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = starts\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map starts\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{starts\_with\_any}}{starts\_with\_any}}\label{starts_with_any}

\texttt{starts\_with\_any} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = starts\_with\_any $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map starts\_with\_any |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{state\_norm}}{state\_norm}}\label{state_norm}

\texttt{state\_norm} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = state\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map state\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{state\_normalize}}{state\_normalize}}\label{state_normalize}

\texttt{state\_normalize} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = state\_normalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map state\_normalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{state\_of\_charge\_kalman}}{state\_of\_charge\_kalman}}\label{state_of_charge_kalman}

\texttt{state\_of\_charge\_kalman} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = state\_of\_charge\_kalman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map state\_of\_charge\_kalman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{state\_space\_kalman}}{state\_space\_kalman}}\label{state_space_kalman}

\texttt{state\_space\_kalman} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = state\_space\_kalman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map state\_space\_kalman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stats\_describe}}{stats\_describe}}\label{stats_describe}

\texttt{stats\_describe} --- statistics (extended) builtin. Alias for
\texttt{describe}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stats\_describe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stats\_describe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stderr\_stat}}{stderr\_stat}}\label{stderr_stat}

\texttt{stderr\_stat} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{standard\_error}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stderr\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stderr\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stefan\_boltzmann}}{stefan\_boltzmann}}\label{stefan_boltzmann}

\texttt{stefan\_boltzmann} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stefan\_boltzmann $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stefan\_boltzmann |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stefan\_boltzmann\_constant}}{stefan\_boltzmann\_constant}}\label{stefan_boltzmann_constant}

\texttt{stefan\_boltzmann\_constant} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stefan\_boltzmann\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stefan\_boltzmann\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stefan\_boltzmann\_radiation}}{stefan\_boltzmann\_radiation}}\label{stefan_boltzmann_radiation}

\texttt{stefan\_boltzmann\_radiation} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stefan\_boltzmann\_radiation $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stefan\_boltzmann\_radiation |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stefan\_boltzmann\_si}}{stefan\_boltzmann\_si}}\label{stefan_boltzmann_si}

\texttt{stefan\_boltzmann\_si} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stefan\_boltzmann\_si $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stefan\_boltzmann\_si |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stefboltz}}{stefboltz}}\label{stefboltz}

\texttt{stefboltz} --- physics formulas builtin. Alias for
\texttt{stefan\_boltzmann}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stefboltz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stefboltz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{steffensen}}{steffensen}}\label{steffensen}

\texttt{steffensen} --- batch 19 builtin. Alias for
\texttt{steffensen\_root}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = steffensen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map steffensen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{steffensen\_root}}{steffensen\_root}}\label{steffensen_root}

\texttt{steffensen\_root} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = steffensen\_root $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map steffensen\_root |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stem\_lancaster}}{stem\_lancaster}}\label{stem_lancaster}

\texttt{stem\_lancaster} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stem\_lancaster $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stem\_lancaster |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{step}}{step}}\label{step}

\texttt{step} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stern\_layer\_capacitance}}{stern\_layer\_capacitance}}\label{stern_layer_capacitance}

\texttt{stern\_layer\_capacitance} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stern\_layer\_capacitance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stern\_layer\_capacitance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stft\_step}}{stft\_step}}\label{stft_step}

\texttt{stft\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stft\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stft\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sthread}}{sthread}}\label{sthread}

\texttt{sthread} --- stress / telemetry extensions builtin. Alias for
\texttt{stress\_thread}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sthread $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sthread |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stiffness\_ratio}}{stiffness\_ratio}}\label{stiffness_ratio}

\texttt{stiffness\_ratio} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stiffness\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stiffness\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stirling}}{stirling}}\label{stirling}

\texttt{stirling} --- math formulas builtin. Alias for
\texttt{stirling\_approx}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stirling $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stirling |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stirling2}}{stirling2}}\label{stirling2}

\texttt{stirling2} (alias \texttt{stirling\_second}) computes the
Stirling number of the second kind S(n,k) --- the number of ways to
partition n elements into k non-empty subsets.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p stirling2(4, 2)   \# 7}
\NormalTok{p stirling2(5, 3)   \# 25}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stirling\_approx}}{stirling\_approx}}\label{stirling_approx}

\texttt{stirling\_approx} --- math formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stirling\_approx $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stirling\_approx |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stl\_decompose}}{stl\_decompose}}\label{stl_decompose}

\texttt{stl\_decompose} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stl\_decompose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stl\_decompose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stoer\_wagner\_step}}{stoer\_wagner\_step}}\label{stoer_wagner_step}

\texttt{stoer\_wagner\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stoer\_wagner\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stoer\_wagner\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stone\_to\_kg}}{stone\_to\_kg}}\label{stone_to_kg}

\texttt{stone\_to\_kg} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stone\_to\_kg $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stormer\_verlet\_step}}{stormer\_verlet\_step}}\label{stormer_verlet_step}

\texttt{stormer\_verlet\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stormer\_verlet\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stormer\_verlet\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strang\_split}}{strang\_split}}\label{strang_split}

\texttt{strang\_split} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strang\_split $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strang\_split |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stratonovich\_correction}}{stratonovich\_correction}}\label{stratonovich_correction}

\texttt{stratonovich\_correction} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stratonovich\_correction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stratonovich\_correction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strdist}}{strdist}}\label{strdist}

\texttt{strdist} --- string processing (uncategorized batch) builtin.
Alias for \texttt{string\_distance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strdist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strdist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{streak\_color\_index}}{streak\_color\_index}}\label{streak_color_index}

\texttt{streak\_color\_index} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = streak\_color\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map streak\_color\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stream\_prompt\_cb}}{stream\_prompt\_cb}}\label{stream_prompt_cb}

\texttt{stream\_prompt\_cb} --- ai primitives (docs/ai\_primitives.md)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stream\_prompt\_cb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stream\_prompt\_cb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{streamfunction\_step}}{streamfunction\_step}}\label{streamfunction_step}

\texttt{streamfunction\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = streamfunction\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map streamfunction\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strehl\_ratio}}{strehl\_ratio}}\label{strehl_ratio}

\texttt{strehl\_ratio} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strehl\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strehl\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strict\_word\_similarity}}{strict\_word\_similarity}}\label{strict_word_similarity}

\texttt{strict\_word\_similarity} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strict\_word\_similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strict\_word\_similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strikethrough}}{strikethrough}}\label{strikethrough}

\texttt{strikethrough} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strikethrough $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strikethrough |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_agg}}{string\_agg}}\label{string_agg}

\texttt{string\_agg} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_agg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_agg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_camel\_to\_snake}}{string\_camel\_to\_snake}}\label{string_camel_to_snake}

\texttt{string\_camel\_to\_snake} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_camel\_to\_snake $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_chars}}{string\_chars}}\label{string_chars}

\texttt{string\_chars} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_count}}{string\_count}}\label{string_count}

\texttt{string\_count} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_distance}}{string\_distance}}\label{string_distance}

\texttt{string\_distance} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_drop\_first}}{string\_drop\_first}}\label{string_drop_first}

\texttt{string\_drop\_first} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_drop\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_drop\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_drop\_last}}{string\_drop\_last}}\label{string_drop_last}

\texttt{string\_drop\_last} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_drop\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_drop\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_drop\_while}}{string\_drop\_while}}\label{string_drop_while}

\texttt{string\_drop\_while} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_drop\_while $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_drop\_while |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_expand\_tabs}}{string\_expand\_tabs}}\label{string_expand_tabs}

\texttt{string\_expand\_tabs} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_expand\_tabs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_expand\_tabs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_intersperse}}{string\_intersperse}}\label{string_intersperse}

\texttt{string\_intersperse} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_intersperse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_intersperse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_kebab\_to\_snake}}{string\_kebab\_to\_snake}}\label{string_kebab_to_snake}

\texttt{string\_kebab\_to\_snake} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_kebab\_to\_snake $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_letter\_frequency}}{string\_letter\_frequency}}\label{string_letter_frequency}

\texttt{string\_letter\_frequency} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_letter\_frequency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_letter\_frequency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_lines\_count}}{string\_lines\_count}}\label{string_lines_count}

\texttt{string\_lines\_count} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_lines\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_lines\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_multiply}}{string\_multiply}}\label{string_multiply}

\texttt{string\_multiply} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_multiply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_multiply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_normalize\_spaces}}{string\_normalize\_spaces}}\label{string_normalize_spaces}

\texttt{string\_normalize\_spaces} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_normalize\_spaces $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_normalize\_spaces |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_partition\_at\_word}}{string\_partition\_at\_word}}\label{string_partition_at_word}

\texttt{string\_partition\_at\_word} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_partition\_at\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_partition\_at\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_replicate}}{string\_replicate}}\label{string_replicate}

\texttt{string\_replicate} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_replicate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_replicate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_snake\_to\_camel}}{string\_snake\_to\_camel}}\label{string_snake_to_camel}

\texttt{string\_snake\_to\_camel} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_snake\_to\_camel $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_snake\_to\_kebab}}{string\_snake\_to\_kebab}}\label{string_snake_to_kebab}

\texttt{string\_snake\_to\_kebab} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_snake\_to\_kebab $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_sort}}{string\_sort}}\label{string_sort}

\texttt{string\_sort} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_sort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_sort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_split\_at\_first}}{string\_split\_at\_first}}\label{string_split_at_first}

\texttt{string\_split\_at\_first} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_split\_at\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_split\_at\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_take\_first}}{string\_take\_first}}\label{string_take_first}

\texttt{string\_take\_first} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_take\_first $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_take\_first |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_take\_last}}{string\_take\_last}}\label{string_take_last}

\texttt{string\_take\_last} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_take\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_take\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_take\_while}}{string\_take\_while}}\label{string_take_while}

\texttt{string\_take\_while} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_take\_while $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_take\_while |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_to\_charcodes}}{string\_to\_charcodes}}\label{string_to_charcodes}

\texttt{string\_to\_charcodes} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_to\_charcodes $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_to\_chars}}{string\_to\_chars}}\label{string_to_chars}

\texttt{string\_to\_chars} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_to\_chars $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_truncate\_ellipsis}}{string\_truncate\_ellipsis}}\label{string_truncate_ellipsis}

\texttt{string\_truncate\_ellipsis} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_truncate\_ellipsis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_truncate\_ellipsis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_uniq\_chars}}{string\_uniq\_chars}}\label{string_uniq_chars}

\texttt{string\_uniq\_chars} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_uniq\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_uniq\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_unique\_chars}}{string\_unique\_chars}}\label{string_unique_chars}

\texttt{string\_unique\_chars} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_unique\_chars $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_unique\_chars |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_words\_count}}{string\_words\_count}}\label{string_words_count}

\texttt{string\_words\_count} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_words\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_words\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{string\_xor}}{string\_xor}}\label{string_xor}

\texttt{string\_xor} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = string\_xor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map string\_xor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strip\_ansi}}{strip\_ansi}}\label{strip_ansi}

\texttt{strip\_ansi} --- color / ansi builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strip\_ansi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strip\_ansi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strip\_html}}{strip\_html}}\label{strip_html}

\texttt{strip\_html} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strip\_html $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strip\_html |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strip\_prefix}}{strip\_prefix}}\label{strip_prefix}

\texttt{strip\_prefix} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strip\_prefix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strip\_prefix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strip\_suffix}}{strip\_suffix}}\label{strip_suffix}

\texttt{strip\_suffix} --- path helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strip\_suffix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strip\_suffix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strlen}}{strlen}}\label{strlen}

\texttt{strlen} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strlen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strlen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strmul}}{strmul}}\label{strmul}

\texttt{strmul} --- string processing (uncategorized batch) builtin.
Alias for \texttt{string\_multiply}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strmul $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strmul |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strong\_pseudoprime}}{strong\_pseudoprime}}\label{strong_pseudoprime}

\texttt{strong\_pseudoprime} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strong\_pseudoprime $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strong\_pseudoprime |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strouhal\_full}}{strouhal\_full}}\label{strouhal_full}

\texttt{strouhal\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strouhal\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strouhal\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{strsm}}{strsm}}\label{strsm}

\texttt{strsm} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = strsm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map strsm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{struve\_h0}}{struve\_h0}}\label{struve_h0}

\texttt{struve\_h0} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = struve\_h0 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map struve\_h0 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{struve\_h1}}{struve\_h1}}\label{struve_h1}

\texttt{struve\_h1} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = struve\_h1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map struve\_h1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{student\_pdf}}{student\_pdf}}\label{student_pdf}

\texttt{t\_pdf} (alias \texttt{tpdf}) evaluates
Student\textquotesingle s t-distribution PDF at x with nu degrees of
freedom.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p tpdf(0, 10)    \# peak of t(10)}
\NormalTok{p tpdf(2.228, 10)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{stulz\_min\_call}}{stulz\_min\_call}}\label{stulz_min_call}

\texttt{stulz\_min\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = stulz\_min\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map stulz\_min\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sturmian\_word}}{sturmian\_word}}\label{sturmian_word}

\texttt{sturmian\_word} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sturmian\_word $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sturmian\_word |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sub}}{sub}}\label{sub}

The \texttt{sub} keyword is not supported in stryke. Use \texttt{fn}
instead to define functions.

\section{\texorpdfstring{\texttt{sub\_script}}{sub\_script}}\label{sub_script}

\texttt{sub\_script} --- encoding / phonetics builtin. Alias for
\texttt{subscript}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sub\_script $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sub\_script |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subfact}}{subfact}}\label{subfact}

\texttt{subfact} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{subfactorial}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subfact $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subfact |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subfactorial}}{subfactorial}}\label{subfactorial}

\texttt{subfactorial} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subfactorial $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subfactorial |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subgame\_perfect\_eq}}{subgame\_perfect\_eq}}\label{subgame_perfect_eq}

\texttt{subgame\_perfect\_eq} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subgame\_perfect\_eq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subgame\_perfect\_eq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subgradient\_step\_size}}{subgradient\_step\_size}}\label{subgradient_step_size}

\texttt{subgradient\_step\_size} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subgradient\_step\_size $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subgradient\_step\_size |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subgraph\_isomorphism}}{subgraph\_isomorphism}}\label{subgraph_isomorphism}

\texttt{subgraph\_isomorphism} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subgraph\_isomorphism $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subgraph\_isomorphism |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{submodular\_curvature\_bound}}{submodular\_curvature\_bound}}\label{submodular_curvature_bound}

\texttt{submodular\_curvature\_bound} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = submodular\_curvature\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map submodular\_curvature\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{submodular\_greedy\_step}}{submodular\_greedy\_step}}\label{submodular_greedy_step}

\texttt{submodular\_greedy\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = submodular\_greedy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map submodular\_greedy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subname}}{subname}}\label{subname}

\texttt{subname} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subname $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subname |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subscript}}{subscript}}\label{subscript}

\texttt{subscript} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subscript $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subscript |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subseqs}}{subseqs}}\label{subseqs}

\texttt{subseqs} --- additional missing stdlib functions builtin. Alias
for \texttt{subsequences}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subseqs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subseqs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subsequences}}{subsequences}}\label{subsequences}

\texttt{subsequences} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subsequences $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subsequences |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subset\_construction}}{subset\_construction}}\label{subset_construction}

\texttt{subset\_construction} --- batch 68 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subset\_construction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subset\_construction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{substitution\_encrypt}}{substitution\_encrypt}}\label{substitution_encrypt}

\texttt{substitution\_encrypt} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = substitution\_encrypt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map substitution\_encrypt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{substring}}{substring}}\label{substring}

\texttt{substring} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = substring $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map substring |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{substring\_count}}{substring\_count}}\label{substring_count}

\texttt{substring\_count} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = substring\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map substring\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{substring\_similarity}}{substring\_similarity}}\label{substring_similarity}

\texttt{substring\_similarity} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = substring\_similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map substring\_similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{subsumption\_check}}{subsumption\_check}}\label{subsumption_check}

\texttt{subsumption\_check} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = subsumption\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map subsumption\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{succ}}{succ}}\label{succ}

\texttt{succ} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = succ $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map succ |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{suffix\_array\_naive}}{suffix\_array\_naive}}\label{suffix_array_naive}

\texttt{suffix\_array\_naive} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = suffix\_array\_naive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map suffix\_array\_naive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{suffix\_sums}}{suffix\_sums}}\label{suffix_sums}

\texttt{suffix\_sums} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = suffix\_sums $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map suffix\_sums |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_by}}{sum\_by}}\label{sum_by}

\texttt{sum\_by} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_degrees}}{sum\_degrees}}\label{sum_degrees}

\texttt{sum\_degrees} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_degrees $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_degrees |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_divisors}}{sum\_divisors}}\label{sum_divisors}

\texttt{sum\_divisors} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_divisors $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_divisors |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_list}}{sum\_list}}\label{sum_list}

\texttt{sum\_list} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_of}}{sum\_of}}\label{sum_of}

\texttt{sum\_of} --- more list helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_squares}}{sum\_squares}}\label{sum_squares}

\texttt{sum\_squares} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_squares $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_squares |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sum\_two\_squares}}{sum\_two\_squares}}\label{sum_two_squares}

\texttt{sum\_two\_squares} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sum\_two\_squares $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sum\_two\_squares |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sumb}}{sumb}}\label{sumb}

\texttt{sumb} --- python/ruby stdlib builtin. Alias for
\texttt{sum\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sumb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sumb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sumif}}{sumif}}\label{sumif}

\texttt{sumif} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sumif $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sumif |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sumifs}}{sumifs}}\label{sumifs}

\texttt{sumifs} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sumifs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sumifs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sumproduct}}{sumproduct}}\label{sumproduct}

\texttt{sumproduct} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sumproduct $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sumproduct |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sumsq}}{sumsq}}\label{sumsq}

\texttt{sumsq} --- extended stdlib builtin. Alias for
\texttt{sum\_squares}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sumsq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sumsq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sun\_distance\_au}}{sun\_distance\_au}}\label{sun_distance_au}

\texttt{sun\_distance\_au} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sun\_distance\_au $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sun\_distance\_au |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sun\_position\_low}}{sun\_position\_low}}\label{sun_position_low}

\texttt{sun\_position\_low} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sun\_position\_low $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sun\_position\_low |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sun\_radius}}{sun\_radius}}\label{sun_radius}

\texttt{sun\_radius} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sun\_radius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sun\_radius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sunion}}{sunion}}\label{sunion}

\texttt{sunion} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sunion $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sunion |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sunspot\_relative\_number}}{sunspot\_relative\_number}}\label{sunspot_relative_number}

\texttt{sunspot\_relative\_number} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sunspot\_relative\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sunspot\_relative\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sup}}{sup}}\label{sup}

\texttt{sup} --- encoding / phonetics builtin. Alias for
\texttt{superscript}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sup $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sup |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{superbee\_limiter}}{superbee\_limiter}}\label{superbee_limiter}

\texttt{superbee\_limiter} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = superbee\_limiter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map superbee\_limiter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{superdense\_coding}}{superdense\_coding}}\label{superdense_coding}

\texttt{superdense\_coding} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = superdense\_coding $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map superdense\_coding |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{supergolden}}{supergolden}}\label{supergolden}

\texttt{supergolden} --- math constants builtin. Alias for
\texttt{supergolden\_ratio}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = supergolden $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map supergolden |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{supergolden\_ratio}}{supergolden\_ratio}}\label{supergolden_ratio}

\texttt{supergolden\_ratio} --- math constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = supergolden\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map supergolden\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{superscript}}{superscript}}\label{superscript}

\texttt{superscript} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = superscript $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map superscript |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{supply\_elasticity}}{supply\_elasticity}}\label{supply_elasticity}

\texttt{supply\_elasticity} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = supply\_elasticity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map supply\_elasticity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{surf\_keypoints}}{surf\_keypoints}}\label{surf_keypoints}

\texttt{surf\_keypoints} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = surf\_keypoints $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map surf\_keypoints |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{surface\_wave\_ms}}{surface\_wave\_ms}}\label{surface_wave_ms}

\texttt{surface\_wave\_ms} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = surface\_wave\_ms $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map surface\_wave\_ms |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{susceptible\_to\_infected}}{susceptible\_to\_infected}}\label{susceptible_to_infected}

\texttt{susceptible\_to\_infected} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = susceptible\_to\_infected $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sw}}{sw}}\label{sw}

\texttt{sw} --- trivial string ops builtin. Alias for
\texttt{starts\_with}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swamee\_jain\_factor}}{swamee\_jain\_factor}}\label{swamee_jain_factor}

\texttt{swamee\_jain\_factor} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swamee\_jain\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swamee\_jain\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swampland\_distance\_check}}{swampland\_distance\_check}}\label{swampland_distance_check}

\texttt{swampland\_distance\_check} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swampland\_distance\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swampland\_distance\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_bits}}{swap\_bits}}\label{swap_bits}

\texttt{swap\_bits} --- batch 10 builtin. Alias for
\texttt{swap\_bits\_pos}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swap\_bits $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swap\_bits |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_bits\_pos}}{swap\_bits\_pos}}\label{swap_bits_pos}

\texttt{swap\_bits\_pos} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swap\_bits\_pos $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swap\_bits\_pos |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_case}}{swap\_case}}\label{swap_case}

\texttt{swap\_case} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swap\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swap\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_free}}{swap\_free}}\label{swap_free}

\texttt{swap\_free} --- free swap space in bytes.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(swap\_free)}
\NormalTok{my $pct = swap\_total \textgreater{} 0 ? int(swap\_free / swap\_total * 100) : 100}
\NormalTok{p "$pct\% swap free"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_indices}}{swap\_indices}}\label{swap_indices}

\texttt{swap\_indices} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swap\_indices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swap\_indices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_pairs}}{swap\_pairs}}\label{swap_pairs}

\texttt{swap\_pairs} --- collection helpers (trivial) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swap\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swap\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_total}}{swap\_total}}\label{swap_total}

\texttt{swap\_total} --- total swap space in bytes. Linux:
\texttt{/proc/meminfo\ SwapTotal}. macOS: \texttt{vm.swapusage} sysctl.
Returns 0 if swap is disabled, \texttt{undef} on unsupported platforms.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p swap\_total                             \# 8589934592}
\NormalTok{p format\_bytes(swap\_total)               \# 8.0 GiB}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swap\_used}}{swap\_used}}\label{swap_used}

\texttt{swap\_used} --- used swap space in bytes (total - free).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p format\_bytes(swap\_used)}
\NormalTok{p "swap pressure" if swap\_used \textgreater{} swap\_total * 0.8}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swave\_velocity\_depth}}{swave\_velocity\_depth}}\label{swave_velocity_depth}

\texttt{swave\_velocity\_depth} --- batch 65 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swave\_velocity\_depth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swave\_velocity\_depth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{swelling\_strain\_step}}{swelling\_strain\_step}}\label{swelling_strain_step}

\texttt{swelling\_strain\_step} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = swelling\_strain\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map swelling\_strain\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sym4\_coeffs}}{sym4\_coeffs}}\label{sym4_coeffs}

\texttt{sym4\_coeffs} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sym4\_coeffs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sym4\_coeffs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sym\_check}}{sym\_check}}\label{sym_check}

\texttt{sym\_check} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sym\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sym\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sym\_links}}{sym\_links}}\label{sym_links}

\texttt{sym\_links} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = sym\_links $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map sym\_links |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{symmetric\_diff}}{symmetric\_diff}}\label{symmetric_diff}

\texttt{symmetric\_diff} --- collection (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = symmetric\_diff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map symmetric\_diff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{symplectic\_euler\_step}}{symplectic\_euler\_step}}\label{symplectic_euler_step}

\texttt{symplectic\_euler\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = symplectic\_euler\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map symplectic\_euler\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{synge\_world\_function}}{synge\_world\_function}}\label{synge_world_function}

\texttt{synge\_world\_function} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = synge\_world\_function $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map synge\_world\_function |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{synodic\_period}}{synodic\_period}}\label{synodic_period}

\texttt{synodic\_period} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = synodic\_period $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map synodic\_period |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{sys\_uptime}}{sys\_uptime}}\label{sys_uptime}

\texttt{sys\_uptime} --- system uptime in seconds (float). On Linux
reads \texttt{/proc/uptime}. On macOS uses \texttt{kern.boottime}
sysctl. This is the wall-clock uptime of the machine, not the stryke
process (see \texttt{uptime\_secs} for process uptime).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p sys\_uptime                             \# 147951.5}
\NormalTok{my $days = int(sys\_uptime / 86400)}
\NormalTok{p "up $days days"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{t1ha}}{t1ha}}\label{t1ha}

\texttt{t1ha} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = t1ha $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map t1ha |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{t\_test\_one\_sample}}{t\_test\_one\_sample}}\label{t_test_one_sample}

\texttt{t\_test\_one\_sample(\$mu,\ @sample)} (alias \texttt{ttest1})
--- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @sample = (5.1, 4.9, 5.2, 5.0, 4.8)}
\NormalTok{my $result = ttest1(5.0, @sample)}
\NormalTok{p "t=$result{-}\textgreater{}[0] df=$result{-}\textgreater{}[1]"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{t\_test\_two\_sample}}{t\_test\_two\_sample}}\label{t_test_two_sample}

\texttt{t\_test\_two\_sample(\textbackslash{}@a,\ \textbackslash{}@b)}
(alias \texttt{ttest2}) --- performs an independent two-sample t-test
comparing means of two samples. Assumes equal variances. Returns
{[}t\_statistic, degrees\_of\_freedom{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @a = (5.1, 5.3, 4.9)}
\NormalTok{my @b = (4.2, 4.5, 4.1)}
\NormalTok{my $r = ttest2(\textbackslash{}@a, \textbackslash{}@b)}
\NormalTok{p "t=$r{-}\textgreater{}[0] df=$r{-}\textgreater{}[1]"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tableau\_branch\_close}}{tableau\_branch\_close}}\label{tableau_branch_close}

\texttt{tableau\_branch\_close} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tableau\_branch\_close $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tableau\_branch\_close |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tabu\_search\_move\_score}}{tabu\_search\_move\_score}}\label{tabu_search_move_score}

\texttt{tabu\_search\_move\_score} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tabu\_search\_move\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tabu\_search\_move\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tabulate}}{tabulate}}\label{tabulate}

\texttt{tabulate} --- frequency table of values. Returns hash of value
=\textgreater{} count. Like R\textquotesingle s table().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%t = \%\{tabulate([qw(a b a c b a)])\}}
\NormalTok{p $t\{a\}  \# 3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tackle\_efficiency}}{tackle\_efficiency}}\label{tackle_efficiency}

\texttt{tackle\_efficiency} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tackle\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tackle\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tafel\_anodic\_current}}{tafel\_anodic\_current}}\label{tafel_anodic_current}

\texttt{tafel\_anodic\_current} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tafel\_anodic\_current $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tafel\_anodic\_current |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tafel\_cathodic\_current}}{tafel\_cathodic\_current}}\label{tafel_cathodic_current}

\texttt{tafel\_cathodic\_current} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tafel\_cathodic\_current $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tafel\_cathodic\_current |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tail\_lines}}{tail\_lines}}\label{tail_lines}

\texttt{tail\_lines} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tail\_lines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tail\_lines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tail\_n}}{tail\_n}}\label{tail_n}

\texttt{tail\_n} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tail\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tail\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tail\_str}}{tail\_str}}\label{tail_str}

\texttt{tail\_str} --- string (batch 2) builtin. Alias for
\texttt{right\_str}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tail\_str $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tail\_str |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tails}}{tails}}\label{tails}

\texttt{tails} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tails $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tails |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tajimas\_d}}{tajimas\_d}}\label{tajimas_d}

\texttt{tajimas\_d} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tajimas\_d $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tajimas\_d |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{take\_every}}{take\_every}}\label{take_every}

\texttt{take\_every} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = take\_every $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map take\_every |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{take\_last}}{take\_last}}\label{take_last}

\texttt{take\_last} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = take\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map take\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{take\_n}}{take\_n}}\label{take_n}

\texttt{take\_n} --- collection helpers (trivial) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = take\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map take\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{talb}}{talb}}\label{talb}

\texttt{talb} --- ruby enumerable extras builtin. Alias for
\texttt{tally\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = talb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map talb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tally\_by}}{tally\_by}}\label{tally_by}

\texttt{tally\_by} --- ruby enumerable extras builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tally\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tally\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tan}}{tan}}\label{tan}

\texttt{tan} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tan $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tan |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tanh}}{tanh}}\label{tanh}

\texttt{tanh} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tanh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tanh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tanh\_grad}}{tanh\_grad}}\label{tanh_grad}

\texttt{tanh\_grad} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tanh\_grad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tanh\_grad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tanimoto\_bits}}{tanimoto\_bits}}\label{tanimoto_bits}

\texttt{tanimoto\_bits} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tanimoto\_bits $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tap\_debug}}{tap\_debug}}\label{tap_debug}

\texttt{tap\_debug} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tap\_debug $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tap\_debug |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tap\_val}}{tap\_val}}\label{tap_val}

\texttt{tap\_val} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tap\_val $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tap\_val |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tapply}}{tapply}}\label{tapply}

\texttt{tapply} --- apply a function by group. Takes data, group labels,
and function. Returns hash. Like R\textquotesingle s tapply().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%means = \%\{tapply([1,2,3,4], ["a","a","b","b"], fn \{ avg(@\{$\_[0]\}) \})\}}
\NormalTok{p $means\{a\}  \# 1.5}
\NormalTok{p $means\{b\}  \# 3.5}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_header\_checksum}}{tar\_header\_checksum}}\label{tar_header_checksum}

\texttt{tar\_header\_checksum} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tar\_header\_checksum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tar\_header\_checksum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_member\_record}}{tar\_member\_record}}\label{tar_member_record}

\texttt{tar\_member\_record} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tar\_member\_record $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tar\_member\_record |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tar\_pad\_512}}{tar\_pad\_512}}\label{tar_pad_512}

\texttt{tar\_pad\_512} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tar\_pad\_512 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tar\_pad\_512 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{target\_heart\_rate}}{target\_heart\_rate}}\label{target_heart_rate}

\texttt{target\_heart\_rate} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = target\_heart\_rate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map target\_heart\_rate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tarjan\_scc\_step}}{tarjan\_scc\_step}}\label{tarjan_scc_step}

\texttt{tarjan\_scc\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tarjan\_scc\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tarjan\_scc\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tau}}{tau}}\label{tau}

\texttt{tau} --- constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tau $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tau |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tax}}{tax}}\label{tax}

\texttt{tax} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tax\_amount}}{tax\_amount}}\label{tax_amount}

\texttt{tax\_amount} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tax\_amount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tax\_amount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tax\_incidence}}{tax\_incidence}}\label{tax_incidence}

\texttt{tax\_incidence} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tax\_incidence $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tax\_incidence |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{taylor\_diagram\_score}}{taylor\_diagram\_score}}\label{taylor_diagram_score}

\texttt{taylor\_diagram\_score} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = taylor\_diagram\_score $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map taylor\_diagram\_score |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{taylor\_microscale\_step}}{taylor\_microscale\_step}}\label{taylor_microscale_step}

\texttt{taylor\_microscale\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = taylor\_microscale\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map taylor\_microscale\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{taylor\_window}}{taylor\_window}}\label{taylor_window}

\texttt{taylor\_window} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = taylor\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map taylor\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tcrossprod}}{tcrossprod}}\label{tcrossprod}

\texttt{tcrossprod} --- M * t(M) (R\textquotesingle s tcrossprod).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $aat = tcrossprod([[1,2],[3,4]])  \# [[5,11],[11,25]]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{td}}{td}}\label{td}

\texttt{td} --- serialization (stryke-only encoders) builtin. Alias for
\texttt{toml\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = td $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map td |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{td\_lambda\_update}}{td\_lambda\_update}}\label{td_lambda_update}

\texttt{td\_lambda\_update} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = td\_lambda\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map td\_lambda\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{td\_zero\_update}}{td\_zero\_update}}\label{td_zero_update}

\texttt{td\_zero\_update} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = td\_zero\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map td\_zero\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tdilate}}{tdilate}}\label{tdilate}

\texttt{time\_dilation(\$proper\_time,\ \$velocity)} (alias
\texttt{tdilate}) --- dilated time Δt = Δt₀ × γ. Time appears to slow
for moving objects.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p tdilate(1, 0.99 * 3e8)   \# \textasciitilde{}7.09 s (1 second at 99\% c)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{te}}{te}}\label{te}

\texttt{te} --- serialization (stryke-only encoders) builtin. Alias for
\texttt{toml\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = te $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map te |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tee\_iter}}{tee\_iter}}\label{tee_iter}

\texttt{tee\_iter} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tee\_iter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tee\_iter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{teei}}{teei}}\label{teei}

\texttt{teei} --- python/ruby stdlib builtin. Alias for
\texttt{tee\_iter}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = teei $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map teei |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{temp\_dir}}{temp\_dir}}\label{temp_dir}

\texttt{temp\_dir} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = temp\_dir $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map temp\_dir |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{template\_match}}{template\_match}}\label{template_match}

\texttt{template\_match} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = template\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map template\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tempo\_to\_ms}}{tempo\_to\_ms}}\label{tempo_to_ms}

\texttt{tempo\_to\_ms} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tempo\_to\_ms $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tempplanck}}{tempplanck}}\label{tempplanck}

\texttt{tempplanck} --- physics constants builtin. Alias for
\texttt{planck\_temperature}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tempplanck $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tempplanck |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tensor\_antisymmetrize\_two}}{tensor\_antisymmetrize\_two}}\label{tensor_antisymmetrize_two}

\texttt{tensor\_antisymmetrize\_two} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tensor\_antisymmetrize\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tensor\_antisymmetrize\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tensor\_contract\_two}}{tensor\_contract\_two}}\label{tensor_contract_two}

\texttt{tensor\_contract\_two} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tensor\_contract\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tensor\_contract\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tensor\_outer\_two}}{tensor\_outer\_two}}\label{tensor_outer_two}

\texttt{tensor\_outer\_two} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tensor\_outer\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tensor\_outer\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tensor\_symmetrize\_two}}{tensor\_symmetrize\_two}}\label{tensor_symmetrize_two}

\texttt{tensor\_symmetrize\_two} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tensor\_symmetrize\_two $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tensor\_symmetrize\_two |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tensor\_trace\_index}}{tensor\_trace\_index}}\label{tensor_trace_index}

\texttt{tensor\_trace\_index} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tensor\_trace\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tensor\_trace\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{term\_life\_a\_n\_t}}{term\_life\_a\_n\_t}}\label{term_life_a_n_t}

\texttt{term\_life\_a\_n\_t} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = term\_life\_a\_n\_t $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map term\_life\_a\_n\_t |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{terminal\_velocity}}{terminal\_velocity}}\label{terminal_velocity}

\texttt{terminal\_velocity} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = terminal\_velocity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map terminal\_velocity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{test\_skip}}{test\_skip}}\label{test_skip}

\texttt{test\_skip} --- testing framework builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = test\_skip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map test\_skip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tetrahedral\_number}}{tetrahedral\_number}}\label{tetrahedral_number}

\texttt{tetrahedral\_number} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tetrahedral\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tetrahedral\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{text\_after}}{text\_after}}\label{text_after}

\texttt{text\_after} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = text\_after $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map text\_after |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{text\_after\_last}}{text\_after\_last}}\label{text_after_last}

\texttt{text\_after\_last} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = text\_after\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map text\_after\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{text\_before}}{text\_before}}\label{text_before}

\texttt{text\_before} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = text\_before $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map text\_before |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{text\_before\_last}}{text\_before\_last}}\label{text_before_last}

\texttt{text\_before\_last} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = text\_before\_last $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map text\_before\_last |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{text\_between}}{text\_between}}\label{text_between}

\texttt{text\_between} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = text\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map text\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tf2sos\_step}}{tf2sos\_step}}\label{tf2sos_step}

\texttt{tf2sos\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tf2sos\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tf2sos\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tf2zpk\_step}}{tf2zpk\_step}}\label{tf2zpk_step}

\texttt{tf2zpk\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tf2zpk\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tf2zpk\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tfld}}{tfld}}\label{tfld}

\texttt{tfld} --- rust iterator methods builtin. Alias for
\texttt{try\_fold}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tfld $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tfld |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{theil\_sen\_slope}}{theil\_sen\_slope}}\label{theil_sen_slope}

\texttt{theil\_sen\_slope} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = theil\_sen\_slope $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map theil\_sen\_slope |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{then\_fn}}{then\_fn}}\label{then_fn}

\texttt{then\_fn} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = then\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map then\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thermal\_mean\_photons}}{thermal\_mean\_photons}}\label{thermal_mean_photons}

\texttt{thermal\_mean\_photons} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thermal\_mean\_photons $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thermal\_mean\_photons |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thermal\_runaway\_threshold}}{thermal\_runaway\_threshold}}\label{thermal_runaway_threshold}

\texttt{thermal\_runaway\_threshold} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thermal\_runaway\_threshold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thermal\_runaway\_threshold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thermal\_wind\_step}}{thermal\_wind\_step}}\label{thermal_wind_step}

\texttt{thermal\_wind\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thermal\_wind\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thermal\_wind\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{theta2}}{theta2}}\label{theta2}

\texttt{theta2} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = theta2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map theta2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{theta3}}{theta3}}\label{theta3}

\texttt{theta3} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = theta3 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map theta3 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thfn}}{thfn}}\label{thfn}

\texttt{thfn} --- python/ruby stdlib builtin. Alias for
\texttt{then\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thfn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thfn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thin\_lens}}{thin\_lens}}\label{thin_lens}

\texttt{thin\_lens(\$object\_dist,\ \$focal\_length)} (alias
\texttt{thinlens}) --- image distance using 1/f = 1/do + 1/di.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p thinlens(30, 20)   \# 60 cm (real image)}
\NormalTok{p thinlens(10, 20)   \# {-}20 cm (virtual image)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thin\_lens\_v}}{thin\_lens\_v}}\label{thin_lens_v}

\texttt{thin\_lens\_v} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thin\_lens\_v $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thin\_lens\_v |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{third\_elem}}{third\_elem}}\label{third_elem}

\texttt{third\_elem} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = third\_elem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map third\_elem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thompson\_sample\_beta}}{thompson\_sample\_beta}}\label{thompson_sample_beta}

\texttt{thompson\_sample\_beta} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thompson\_sample\_beta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thompson\_sample\_beta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{three\_opt\_delta}}{three\_opt\_delta}}\label{three_opt_delta}

\texttt{three\_opt\_delta} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = three\_opt\_delta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map three\_opt\_delta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{threshold\_act}}{threshold\_act}}\label{threshold_act}

\texttt{threshold\_act} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = threshold\_act $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map threshold\_act |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{threshold\_hard\_value}}{threshold\_hard\_value}}\label{threshold_hard_value}

\texttt{threshold\_hard\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = threshold\_hard\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map threshold\_hard\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{threshold\_soft\_value}}{threshold\_soft\_value}}\label{threshold_soft_value}

\texttt{threshold\_soft\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = threshold\_soft\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map threshold\_soft\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{thue\_morse\_string}}{thue\_morse\_string}}\label{thue_morse_string}

\texttt{thue\_morse\_string} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = thue\_morse\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map thue\_morse\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ti2}}{ti2}}\label{ti2}

\texttt{ti2} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ti2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ti2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tidal\_force}}{tidal\_force}}\label{tidal_force}

\texttt{tidal\_force} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tidal\_force $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tidal\_force |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tied}}{tied}}\label{tied}

\texttt{tied} --- type / reflection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tied $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tied |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tile\_xyz\_to\_lat\_lng}}{tile\_xyz\_to\_lat\_lng}}\label{tile_xyz_to_lat_lng}

\texttt{tile\_xyz\_to\_lat\_lng} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tile\_xyz\_to\_lat\_lng $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{time\_sig\_subdivision}}{time\_sig\_subdivision}}\label{time_sig_subdivision}

\texttt{time\_sig\_subdivision} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = time\_sig\_subdivision $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map time\_sig\_subdivision |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{times\_fn}}{times\_fn}}\label{times_fn}

\texttt{times\_fn} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = times\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map times\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{timf}}{timf}}\label{timf}

\texttt{timf} --- python/ruby stdlib builtin. Alias for
\texttt{times\_fn}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = timf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map timf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tip}}{tip}}\label{tip}

\texttt{tip} --- finance builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tip\_amount}}{tip\_amount}}\label{tip_amount}

\texttt{tip\_amount} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tip\_amount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tip\_amount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tisserand\_param}}{tisserand\_param}}\label{tisserand_param}

\texttt{tisserand\_param} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tisserand\_param $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tisserand\_param |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tit\_for\_tat\_step}}{tit\_for\_tat\_step}}\label{tit_for_tat_step}

\texttt{tit\_for\_tat\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tit\_for\_tat\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tit\_for\_tat\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{title}}{title}}\label{title}

\texttt{title} --- trivial string ops builtin. Alias for
\texttt{title\_case}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = title $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map title |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{title\_case}}{title\_case}}\label{title_case}

\texttt{title\_case} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = title\_case $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map title\_case |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{title\_words}}{title\_words}}\label{title_words}

\texttt{title\_words} --- batch 9 builtin. Alias for
\texttt{capitalize\_words}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = title\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map title\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{titration\_endpoint\_index}}{titration\_endpoint\_index}}\label{titration_endpoint_index}

\texttt{titration\_endpoint\_index} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = titration\_endpoint\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map titration\_endpoint\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{titration\_ph\_endpoint}}{titration\_ph\_endpoint}}\label{titration_ph_endpoint}

\texttt{titration\_ph\_endpoint} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = titration\_ph\_endpoint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map titration\_ph\_endpoint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{titration\_volume}}{titration\_volume}}\label{titration_volume}

\texttt{titration\_volume} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = titration\_volume $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map titration\_volume |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tkeys}}{tkeys}}\label{tkeys}

\texttt{tkeys} --- python/ruby stdlib builtin. Alias for
\texttt{transform\_keys}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tkeys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tkeys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tle\_mean\_motion}}{tle\_mean\_motion}}\label{tle_mean_motion}

\texttt{tle\_mean\_motion} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tle\_mean\_motion $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tle\_mean\_motion |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tm\_marmur}}{tm\_marmur}}\label{tm_marmur}

\texttt{tm\_marmur} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tm\_marmur $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tm\_marmur |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tm\_wallace}}{tm\_wallace}}\label{tm_wallace}

\texttt{tm\_wallace} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tm\_wallace $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tm\_wallace |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_array}}{to\_array}}\label{to_array}

\texttt{to\_array} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_array $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_ascii}}{to\_ascii}}\label{to_ascii}

\texttt{to\_ascii} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_ascii $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_base}}{to\_base}}\label{to_base}

\texttt{to\_base} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_base $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_bin}}{to\_bin}}\label{to_bin}

\texttt{to\_bin} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_bin $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_bool}}{to\_bool}}\label{to_bool}

\texttt{to\_bool} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_bool $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_csv\_line}}{to\_csv\_line}}\label{to_csv_line}

\texttt{to\_csv\_line} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_csv\_line $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_emoji\_num}}{to\_emoji\_num}}\label{to_emoji_num}

\texttt{to\_emoji\_num} --- encoding / phonetics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_emoji\_num $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_float}}{to\_float}}\label{to_float}

\texttt{to\_float} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_float $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_float\_each}}{to\_float\_each}}\label{to_float_each}

\texttt{to\_float\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_float\_each $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_hash}}{to\_hash}}\label{to_hash}

\texttt{to\_hash\ LIST} --- collect a flat list of key-value pairs into
a Perl hash.

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 \texttt{undef}. This is a
terminal operation that materializes the full stream. Useful for
converting pipeline output into a lookup table.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my \%h = qw(a 1 b 2) |\textgreater{} to\_hash}
\NormalTok{@pairs |\textgreater{} to\_hash}
\NormalTok{my \%freq = @words |\textgreater{} map \{ \_, 1 \} |\textgreater{} to\_hash}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_hex}}{to\_hex}}\label{to_hex}

\texttt{to\_hex} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_hex $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_int}}{to\_int}}\label{to_int}

\texttt{to\_int} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_int $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_int\_each}}{to\_int\_each}}\label{to_int_each}

\texttt{to\_int\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_int\_each $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_oct}}{to\_oct}}\label{to_oct}

\texttt{to\_oct} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_oct $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_pairs}}{to\_pairs}}\label{to_pairs}

\texttt{to\_pairs} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_pairs $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_reversed}}{to\_reversed}}\label{to_reversed}

\texttt{to\_reversed} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_reversed $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_set}}{to\_set}}\label{to_set}

\texttt{to\_set\ LIST} --- collect a list or iterator into a
\texttt{set} object with O(1) membership testing.

The resulting set contains only unique elements (duplicates are
discarded). This is a terminal operation that materializes the full
stream. The returned set supports
\texttt{-\textgreater{}contains(\$val)},
\texttt{-\textgreater{}union(\$other)},
\texttt{-\textgreater{}intersection(\$other)}, and
\texttt{-\textgreater{}difference(\$other)}. Use this when you need fast
repeated lookups against a collection of values.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $s = 1:5 |\textgreater{} to\_set}
\NormalTok{@words |\textgreater{} to\_set                      \# deduplicated set}
\NormalTok{my $allowed = to\_set @whitelist}
\NormalTok{p $allowed{-}\textgreater{}contains("foo")}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_sorted}}{to\_sorted}}\label{to_sorted}

\texttt{to\_sorted} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_sorted $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_spliced}}{to\_spliced}}\label{to_spliced}

\texttt{to\_spliced} --- javascript array/object methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_spliced $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_string}}{to\_string}}\label{to_string}

\texttt{to\_string} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_string $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{to\_string\_val}}{to\_string\_val}}\label{to_string_val}

\texttt{to\_string\_val} --- misc / utility builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = to\_string\_val $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{toasc}}{toasc}}\label{toasc}

\texttt{toasc} --- extended stdlib builtin. Alias for
\texttt{to\_ascii}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = toasc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map toasc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tobit\_log\_likelihood}}{tobit\_log\_likelihood}}\label{tobit_log_likelihood}

\texttt{tobit\_log\_likelihood} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tobit\_log\_likelihood $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tobit\_log\_likelihood |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{today}}{today}}\label{today}

\texttt{today} --- date (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = today $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map today |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{todd\_genus\_eval}}{todd\_genus\_eval}}\label{todd_genus_eval}

\texttt{todd\_genus\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = todd\_genus\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map todd\_genus\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{toffoli\_gate}}{toffoli\_gate}}\label{toffoli_gate}

\texttt{toffoli\_gate} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = toffoli\_gate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map toffoli\_gate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{token}}{token}}\label{token}

\texttt{token} --- id helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = token $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map token |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tomorrow}}{tomorrow}}\label{tomorrow}

\texttt{tomorrow} --- date (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tomorrow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tomorrow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{top}}{top}}\label{top}

\texttt{top} --- pipeline / string helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = top $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map top |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{top\_trading\_cycle}}{top\_trading\_cycle}}\label{top_trading_cycle}

\texttt{top\_trading\_cycle} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = top\_trading\_cycle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map top\_trading\_cycle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{top\_trading\_cycles\_step}}{top\_trading\_cycles\_step}}\label{top_trading_cycles_step}

\texttt{top\_trading\_cycles\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = top\_trading\_cycles\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map top\_trading\_cycles\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{topk\_indices}}{topk\_indices}}\label{topk_indices}

\texttt{topk\_indices} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = topk\_indices $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map topk\_indices |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{topo\_kahn\_step}}{topo\_kahn\_step}}\label{topo_kahn_step}

\texttt{topo\_kahn\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = topo\_kahn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map topo\_kahn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{topological\_sort}}{topological\_sort}}\label{topological_sort}

\texttt{topological\_sort} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = topological\_sort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map topological\_sort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{topological\_sort\_kahn}}{topological\_sort\_kahn}}\label{topological_sort_kahn}

\texttt{topological\_sort\_kahn} --- batch 24 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = topological\_sort\_kahn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map topological\_sort\_kahn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{toposort}}{toposort}}\label{toposort}

\texttt{toposort} --- extended stdlib builtin. Alias for
\texttt{topological\_sort}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = toposort $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map toposort |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{torque}}{torque}}\label{torque}

\texttt{torque(\$force,\ \$lever\_arm,\ \$angle)} --- compute torque τ =
r×F×sin(θ) (N⋅m). Angle in degrees, default 90.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p torque(50, 0.5)     \# 25 N⋅m (perpendicular force)}
\NormalTok{p torque(50, 0.5, 30) \# 12.5 N⋅m}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{torsion\_coefficient}}{torsion\_coefficient}}\label{torsion_coefficient}

\texttt{torsion\_coefficient} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = torsion\_coefficient $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map torsion\_coefficient |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tortuosity\_estimate\_bruggeman}}{tortuosity\_estimate\_bruggeman}}\label{tortuosity_estimate_bruggeman}

\texttt{tortuosity\_estimate\_bruggeman} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tortuosity\_estimate\_bruggeman $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tortuosity\_estimate\_bruggeman |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{torus\_surface}}{torus\_surface}}\label{torus_surface}

\texttt{torus\_surface(\$major\_r,\ \$minor\_r)} --- computes the
surface area of a torus. Returns \texttt{4π²Rr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p torus\_surface(10, 2)   \# \textasciitilde{}789.6}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{torus\_volume}}{torus\_volume}}\label{torus_volume}

\texttt{torus\_volume(\$major\_r,\ \$minor\_r)} --- computes the volume
of a torus with major radius R (center to tube center) and minor radius
r (tube radius). Returns \texttt{2π²Rr²}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p torus\_volume(10, 2)   \# \textasciitilde{}789.6}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{torussurf}}{torussurf}}\label{torussurf}

\texttt{torussurf} --- geometry (extended) builtin. Alias for
\texttt{torus\_surface}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = torussurf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map torussurf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{torusvol}}{torusvol}}\label{torusvol}

\texttt{torusvol} --- geometry (extended) builtin. Alias for
\texttt{torus\_volume}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = torusvol $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map torusvol |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{total\_solar\_irradiance\_step}}{total\_solar\_irradiance\_step}}\label{total_solar_irradiance_step}

\texttt{total\_solar\_irradiance\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = total\_solar\_irradiance\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map total\_solar\_irradiance\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{total\_variation\_distance}}{total\_variation\_distance}}\label{total_variation_distance}

\texttt{total\_variation\_distance} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = total\_variation\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map total\_variation\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{totient\_sum}}{totient\_sum}}\label{totient_sum}

\texttt{totient\_sum} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = totient\_sum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map totient\_sum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{totsum}}{totsum}}\label{totsum}

\texttt{totsum} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{totient\_sum}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = totsum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map totsum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{touch}}{touch}}\label{touch}

\texttt{touch} --- filesystem extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = touch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map touch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tov\_mass\_limit}}{tov\_mass\_limit}}\label{tov_mass_limit}

\texttt{tov\_mass\_limit} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tov\_mass\_limit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tov\_mass\_limit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tower\_of\_hanoi}}{tower\_of\_hanoi}}\label{tower_of_hanoi}

\texttt{tower\_of\_hanoi} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tower\_of\_hanoi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tower\_of\_hanoi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tplanck}}{tplanck}}\label{tplanck}

\texttt{tplanck} --- physics constants builtin. Alias for
\texttt{planck\_time}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tplanck $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tplanck |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trace\_distance}}{trace\_distance}}\label{trace_distance}

\texttt{trace\_distance} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trace\_distance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trace\_distance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trade\_wind\_speed}}{trade\_wind\_speed}}\label{trade_wind_speed}

\texttt{trade\_wind\_speed} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trade\_wind\_speed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trade\_wind\_speed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tragedy\_commons\_metric}}{tragedy\_commons\_metric}}\label{tragedy_commons_metric}

\texttt{tragedy\_commons\_metric} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tragedy\_commons\_metric $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tragedy\_commons\_metric |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trailing\_zeros}}{trailing\_zeros}}\label{trailing_zeros}

\texttt{trailing\_zeros} --- base conversion builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trailing\_zeros $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trailing\_zeros |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trait}}{trait}}\label{trait}

\texttt{trait} declares an interface that classes can implement via
\texttt{impl}. Traits define method signatures that implementing classes
must provide.

\textbf{Declaration:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{trait Printable \{}
\NormalTok{    fn to\_str          \# required (no body)}
\NormalTok{    fn debug \{ ... \}   \# optional default impl}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\textbf{Implementation:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Item impl Printable \{}
\NormalTok{    name: Str}
\NormalTok{    fn to\_str \{ $self{-}\textgreater{}name \}}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

\textbf{Multiple traits:}

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{class Widget impl Printable, Comparable \{}
\NormalTok{    ...}
\NormalTok{\}}
\end{Highlighting}
\end{Shaded}

Note: trait method bodies provide default implementations; classes can
override them.

\section{\texorpdfstring{\texttt{trans\_check}}{trans\_check}}\label{trans_check}

\texttt{trans\_check} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trans\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trans\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transcribe\_dna\_rna}}{transcribe\_dna\_rna}}\label{transcribe_dna_rna}

\texttt{transcribe\_dna\_rna} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transcribe\_dna\_rna $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transcribe\_dna\_rna |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transform\_keys}}{transform\_keys}}\label{transform_keys}

\texttt{transform\_keys} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transform\_keys $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transform\_keys |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transform\_values}}{transform\_values}}\label{transform_values}

\texttt{transform\_values} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transform\_values $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transform\_values |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transition\_arc\_eager}}{transition\_arc\_eager}}\label{transition_arc_eager}

\texttt{transition\_arc\_eager} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transition\_arc\_eager $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transition\_arc\_eager |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transition\_arc\_standard}}{transition\_arc\_standard}}\label{transition_arc_standard}

\texttt{transition\_arc\_standard} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transition\_arc\_standard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transition\_arc\_standard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transitivity}}{transitivity}}\label{transitivity}

\texttt{transitivity} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transitivity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transitivity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{translate}}{translate}}\label{translate}

\texttt{translate} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = translate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map translate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{translate\_dna}}{translate\_dna}}\label{translate_dna}

\texttt{translate\_dna} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = translate\_dna $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map translate\_dna |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{translate\_point}}{translate\_point}}\label{translate_point}

\texttt{translate\_point(\$x,\ \$y,\ \$dx,\ \$dy)} --- translates a 2D
point by offset (dx, dy). Returns {[}\$x+\$dx, \$y+\$dy{]}. Basic vector
addition.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $p = translate\_point(1, 2, 3, 4)}
\NormalTok{p @$p   \# (4, 6)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transmission\_pair\_index}}{transmission\_pair\_index}}\label{transmission_pair_index}

\texttt{transmission\_pair\_index} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transmission\_pair\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transmission\_pair\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transmittance}}{transmittance}}\label{transmittance}

\texttt{transmittance} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transmittance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transmittance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transmittance\_to\_a}}{transmittance\_to\_a}}\label{transmittance_to_a}

\texttt{transmittance\_to\_a} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transmittance\_to\_a $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transpose}}{transpose}}\label{transpose}

\texttt{transpose} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transpose $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transpose |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transpose\_axis}}{transpose\_axis}}\label{transpose_axis}

\texttt{transpose\_axis} --- batch 54 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transpose\_axis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transpose\_axis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transpose\_freq\_semitones}}{transpose\_freq\_semitones}}\label{transpose_freq_semitones}

\texttt{transpose\_freq\_semitones} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transpose\_freq\_semitones $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transpose\_freq\_semitones |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transpose\_semi}}{transpose\_semi}}\label{transpose_semi}

\texttt{transpose\_semi} --- batch 9 builtin. Alias for
\texttt{transpose\_freq\_semitones}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transpose\_semi $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transpose\_semi |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{transpt}}{transpt}}\label{transpt}

\texttt{transpt} --- geometry (extended) builtin. Alias for
\texttt{translate\_point}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = transpt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map transpt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trapezoid}}{trapezoid}}\label{trapezoid}

\texttt{trapz} (alias \texttt{trapezoid}) integrates evenly-spaced
samples using the trapezoidal rule. Optional dx (default 1).

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @y = map \{ \_ ** 2 \} 0:100}
\NormalTok{p trapz(\textbackslash{}@y, 0.01)  \# ≈ 0.3333}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trapezoidal\_lte}}{trapezoidal\_lte}}\label{trapezoidal_lte}

\texttt{trapezoidal\_lte} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trapezoidal\_lte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trapezoidal\_lte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trapped\_surface\_check}}{trapped\_surface\_check}}\label{trapped_surface_check}

\texttt{trapped\_surface\_check} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trapped\_surface\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trapped\_surface\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trasatti\_voltammetry\_charge}}{trasatti\_voltammetry\_charge}}\label{trasatti_voltammetry_charge}

\texttt{trasatti\_voltammetry\_charge} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trasatti\_voltammetry\_charge $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trasatti\_voltammetry\_charge |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tree\_kernel\_collins}}{tree\_kernel\_collins}}\label{tree_kernel_collins}

\texttt{tree\_kernel\_collins} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tree\_kernel\_collins $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tree\_kernel\_collins |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trev}}{trev}}\label{trev}

\texttt{trev} --- javascript array/object methods builtin. Alias for
\texttt{to\_reversed}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trev $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trev |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{treynor\_ratio}}{treynor\_ratio}}\label{treynor_ratio}

\texttt{treynor\_ratio} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = treynor\_ratio $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map treynor\_ratio |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trial\_smallest\_factor}}{trial\_smallest\_factor}}\label{trial_smallest_factor}

\texttt{trial\_smallest\_factor} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trial\_smallest\_factor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trial\_smallest\_factor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangle\_area\_heron}}{triangle\_area\_heron}}\label{triangle_area_heron}

\texttt{triangle\_area\_heron} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangle\_area\_heron $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangle\_area\_heron |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangle\_area\_pts}}{triangle\_area\_pts}}\label{triangle_area_pts}

\texttt{triangle\_area\_pts} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangle\_area\_pts $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangle\_area\_pts |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangle\_circumradius}}{triangle\_circumradius}}\label{triangle_circumradius}

\texttt{triangle\_circumradius} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangle\_circumradius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangle\_circumradius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangle\_hypotenuse}}{triangle\_hypotenuse}}\label{triangle_hypotenuse}

\texttt{triangle\_hypotenuse} --- geometry / physics builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangle\_hypotenuse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangle\_hypotenuse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangle\_inradius}}{triangle\_inradius}}\label{triangle_inradius}

\texttt{triangle\_inradius} --- batch 28 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangle\_inradius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangle\_inradius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangles\_count}}{triangles\_count}}\label{triangles_count}

\texttt{triangles\_count} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangles\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangles\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangular\_number}}{triangular\_number}}\label{triangular_number}

\texttt{triangular\_number} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangular\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangular\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triangular\_seq}}{triangular\_seq}}\label{triangular_seq}

\texttt{triangular\_seq} --- sequences builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triangular\_seq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triangular\_seq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trib}}{trib}}\label{trib}

\texttt{trib} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{tribonacci}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trib $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trib |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tribonacci}}{tribonacci}}\label{tribonacci}

\texttt{tribonacci} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tribonacci $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tribonacci |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trigamma}}{trigamma}}\label{trigamma}

\texttt{trigamma} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trigamma $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trigamma |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trigger\_strategy\_payoff}}{trigger\_strategy\_payoff}}\label{trigger_strategy_payoff}

\texttt{trigger\_strategy\_payoff} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trigger\_strategy\_payoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trigger\_strategy\_payoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trigram}}{trigram}}\label{trigram}

\texttt{trigram} --- string processing (uncategorized batch) builtin.
Alias for \texttt{trigrams}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trigram $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trigram |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trigram\_perplexity}}{trigram\_perplexity}}\label{trigram_perplexity}

\texttt{trigram\_perplexity} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trigram\_perplexity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trigram\_perplexity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trigrams}}{trigrams}}\label{trigrams}

\texttt{trigrams} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trigrams $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trigrams |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trim\_each}}{trim\_each}}\label{trim_each}

\texttt{trim\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trim\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trim\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trim\_left}}{trim\_left}}\label{trim_left}

\texttt{trim\_left} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trim\_left $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trim\_left |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trim\_right}}{trim\_right}}\label{trim_right}

\texttt{trim\_right} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trim\_right $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trim\_right |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trimmed\_mean}}{trimmed\_mean}}\label{trimmed_mean}

\texttt{trimmed\_mean} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trimmed\_mean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trimmed\_mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trinomial\_call}}{trinomial\_call}}\label{trinomial_call}

\texttt{trinomial\_call} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trinomial\_call $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trinomial\_call |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trinum}}{trinum}}\label{trinum}

\texttt{trinum} --- number theory / primes builtin. Alias for
\texttt{triangular\_number}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trinum $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trinum |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{triple}}{triple}}\label{triple}

\texttt{triple} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = triple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map triple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trpo\_kl\_constraint}}{trpo\_kl\_constraint}}\label{trpo_kl_constraint}

\texttt{trpo\_kl\_constraint} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trpo\_kl\_constraint $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trpo\_kl\_constraint |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trueskill\_match\_quality}}{trueskill\_match\_quality}}\label{trueskill_match_quality}

\texttt{trueskill\_match\_quality} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trueskill\_match\_quality $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trueskill\_match\_quality |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trueskill\_update}}{trueskill\_update}}\label{trueskill_update}

\texttt{trueskill\_update} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trueskill\_update $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trueskill\_update |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trunc}}{trunc}}\label{trunc}

\texttt{trunc} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trunc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trunc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{truncate\_at}}{truncate\_at}}\label{truncate_at}

\texttt{truncate\_at} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = truncate\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map truncate\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{truncn}}{truncn}}\label{truncn}

\texttt{truncn} --- trivial numeric / predicate builtins builtin. Alias
for \texttt{trunc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = truncn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map truncn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{trust\_game\_repayment}}{trust\_game\_repayment}}\label{trust_game_repayment}

\texttt{trust\_game\_repayment} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = trust\_game\_repayment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map trust\_game\_repayment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{truth\_table}}{truth\_table}}\label{truth_table}

\texttt{truth\_table} --- algorithms / puzzles builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = truth\_table $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map truth\_table |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{truthful\_mechanism\_check}}{truthful\_mechanism\_check}}\label{truthful_mechanism_check}

\texttt{truthful\_mechanism\_check} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = truthful\_mechanism\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map truthful\_mechanism\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{truthy\_count}}{truthy\_count}}\label{truthy_count}

\texttt{truthy\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = truthy\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map truthy\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{try\_fn}}{try\_fn}}\label{try_fn}

\texttt{try\_fn} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = try\_fn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map try\_fn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{try\_fold}}{try\_fold}}\label{try_fold}

\texttt{try\_fold} --- rust iterator methods builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = try\_fold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map try\_fold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ts\_headline}}{ts\_headline}}\label{ts_headline}

\texttt{ts\_headline} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ts\_headline $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ts\_headline |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ts\_match}}{ts\_match}}\label{ts_match}

\texttt{ts\_match} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ts\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ts\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ts\_rank}}{ts\_rank}}\label{ts_rank}

\texttt{ts\_rank} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ts\_rank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ts\_rank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsirelson\_bound}}{tsirelson\_bound}}\label{tsirelson_bound}

\texttt{tsirelson\_bound} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsirelson\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsirelson\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsp\_christofides}}{tsp\_christofides}}\label{tsp_christofides}

\texttt{tsp\_christofides} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsp\_christofides $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsp\_christofides |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsp\_held\_karp}}{tsp\_held\_karp}}\label{tsp_held_karp}

\texttt{tsp\_held\_karp} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsp\_held\_karp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsp\_held\_karp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsp\_held\_karp\_step}}{tsp\_held\_karp\_step}}\label{tsp_held_karp_step}

\texttt{tsp\_held\_karp\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsp\_held\_karp\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsp\_held\_karp\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsp\_lower\_bound\_mst}}{tsp\_lower\_bound\_mst}}\label{tsp_lower_bound_mst}

\texttt{tsp\_lower\_bound\_mst} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsp\_lower\_bound\_mst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsp\_lower\_bound\_mst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsp\_nn\_step}}{tsp\_nn\_step}}\label{tsp_nn_step}

\texttt{tsp\_nn\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsp\_nn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsp\_nn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tspl}}{tspl}}\label{tspl}

\texttt{tspl} --- javascript array/object methods builtin. Alias for
\texttt{to\_spliced}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tspl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tspl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tsrt}}{tsrt}}\label{tsrt}

\texttt{tsrt} --- javascript array/object methods builtin. Alias for
\texttt{to\_sorted}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tsrt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tsrt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tstr}}{tstr}}\label{tstr}

\texttt{tstr} --- misc / utility builtin. Alias for
\texttt{to\_string\_val}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tstr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tstr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tt\_to\_tdb}}{tt\_to\_tdb}}\label{tt_to_tdb}

\texttt{tt\_to\_tdb} --- batch 55 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tt\_to\_tdb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ttable}}{ttable}}\label{ttable}

\texttt{ttable} --- algorithms / puzzles builtin. Alias for
\texttt{truth\_table}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ttable $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ttable |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ttl}}{ttl}}\label{ttl}

\texttt{ttl} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ttl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ttl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tukey\_lambda\_quantile}}{tukey\_lambda\_quantile}}\label{tukey_lambda_quantile}

\texttt{tukey\_lambda\_quantile} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tukey\_lambda\_quantile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tukey\_lambda\_quantile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tukey\_w}}{tukey\_w}}\label{tukey_w}

\texttt{tukey\_w} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tukey\_w $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tukey\_w |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tukey\_window}}{tukey\_window}}\label{tukey_window}

\texttt{tukey\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tukey\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tukey\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tunneling\_prob}}{tunneling\_prob}}\label{tunneling_prob}

\texttt{tunneling\_prob} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tunneling\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tunneling\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{turaev\_alexander\_step}}{turaev\_alexander\_step}}\label{turaev_alexander_step}

\texttt{turaev\_alexander\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = turaev\_alexander\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map turaev\_alexander\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{turbulence\_intensity\_step}}{turbulence\_intensity\_step}}\label{turbulence_intensity_step}

\texttt{turbulence\_intensity\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = turbulence\_intensity\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map turbulence\_intensity\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{turbulent\_dissipation\_eps}}{turbulent\_dissipation\_eps}}\label{turbulent_dissipation_eps}

\texttt{turbulent\_dissipation\_eps} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = turbulent\_dissipation\_eps $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map turbulent\_dissipation\_eps |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{turbulent\_kinetic\_energy\_step}}{turbulent\_kinetic\_energy\_step}}\label{turbulent_kinetic_energy_step}

\texttt{turbulent\_kinetic\_energy\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = turbulent\_kinetic\_energy\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map turbulent\_kinetic\_energy\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tvals}}{tvals}}\label{tvals}

\texttt{tvals} --- python/ruby stdlib builtin. Alias for
\texttt{transform\_values}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tvals $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tvals |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tversky}}{tversky}}\label{tversky}

\texttt{tversky} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tversky $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tversky |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{twin\_primes}}{twin\_primes}}\label{twin_primes}

\texttt{twin\_primes} --- number theory / primes builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = twin\_primes $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map twin\_primes |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{twinp}}{twinp}}\label{twinp}

\texttt{twinp} --- number theory / primes builtin. Alias for
\texttt{twin\_primes}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = twinp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map twinp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{twist\_tensor\_step}}{twist\_tensor\_step}}\label{twist_tensor_step}

\texttt{twist\_tensor\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = twist\_tensor\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map twist\_tensor\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{two\_opt\_swap\_delta}}{two\_opt\_swap\_delta}}\label{two_opt_swap_delta}

\texttt{two\_opt\_swap\_delta} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = two\_opt\_swap\_delta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map two\_opt\_swap\_delta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{two\_sls\_iv}}{two\_sls\_iv}}\label{two_sls_iv}

\texttt{two\_sls\_iv} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = two\_sls\_iv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map two\_sls\_iv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{two\_watched\_literals}}{two\_watched\_literals}}\label{two_watched_literals}

\texttt{two\_watched\_literals} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = two\_watched\_literals $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map two\_watched\_literals |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{txaft}}{txaft}}\label{txaft}

\texttt{txaft} --- extended stdlib builtin. Alias for
\texttt{text\_after}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = txaft $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map txaft |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{txaftl}}{txaftl}}\label{txaftl}

\texttt{txaftl} --- extended stdlib builtin. Alias for
\texttt{text\_after\_last}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = txaftl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map txaftl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{txbef}}{txbef}}\label{txbef}

\texttt{txbef} --- extended stdlib builtin. Alias for
\texttt{text\_before}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = txbef $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map txbef |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{txbefl}}{txbefl}}\label{txbefl}

\texttt{txbefl} --- extended stdlib builtin. Alias for
\texttt{text\_before\_last}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = txbefl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map txbefl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{txbtwn}}{txbtwn}}\label{txbtwn}

\texttt{txbtwn} --- extended stdlib builtin. Alias for
\texttt{text\_between}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = txbtwn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map txbtwn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{type}}{type}}\label{type}

\texttt{type} --- misc / utility builtin. Alias for \texttt{type\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = type $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map type |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{type\_each}}{type\_each}}\label{type_each}

\texttt{type\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = type\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map type\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{type\_of}}{type\_of}}\label{type_of}

\texttt{type\_of} --- misc / utility builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = type\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map type\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{type\_redis}}{type\_redis}}\label{type_redis}

\texttt{type\_redis} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = type\_redis $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map type\_redis |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{typeof}}{typeof}}\label{typeof}

\texttt{typeof} --- misc / utility builtin. Alias for \texttt{type\_of}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = typeof $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map typeof |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{tz}}{tz}}\label{tz}

\texttt{tz} --- base conversion builtin. Alias for
\texttt{trailing\_zeros}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = tz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map tz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ubound}}{ubound}}\label{ubound}

\texttt{ubound} --- extended stdlib builtin. Alias for
\texttt{upper\_bound}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ubound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ubound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ucb1\_action\_value}}{ucb1\_action\_value}}\label{ucb1_action_value}

\texttt{ucb1\_action\_value} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ucb1\_action\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ucb1\_action\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ucm\_unobserved\_components}}{ucm\_unobserved\_components}}\label{ucm_unobserved_components}

\texttt{ucm\_unobserved\_components} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ucm\_unobserved\_components $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ucm\_unobserved\_components |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ud}}{ud}}\label{ud}

\texttt{ud} --- crypto / encoding builtin. Alias for
\texttt{url\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ud $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ud |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ue}}{ue}}\label{ue}

\texttt{ue} --- crypto / encoding builtin. Alias for
\texttt{url\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ue $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ue |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ugz}}{ugz}}\label{ugz}

\texttt{ugz} --- crypto / encoding builtin. Alias for \texttt{gunzip}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ugz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ugz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uid}}{uid}}\label{uid}

\texttt{uid} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uid $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uid |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uin}}{uin}}\label{uin}

\texttt{uin} --- algebraic match builtin. Alias for \texttt{update\_in}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ultimatum\_acceptance\_prob}}{ultimatum\_acceptance\_prob}}\label{ultimatum_acceptance_prob}

\texttt{ultimatum\_acceptance\_prob} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ultimatum\_acceptance\_prob $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ultimatum\_acceptance\_prob |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uncertainty\_position}}{uncertainty\_position}}\label{uncertainty_position}

\texttt{uncertainty\_position} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uncertainty\_position $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uncertainty\_position |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{undef\_count}}{undef\_count}}\label{undef_count}

\texttt{undef\_count} --- counters (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = undef\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map undef\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{underline}}{underline}}\label{underline}

\texttt{underline} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = underline $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map underline |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unfold}}{unfold}}\label{unfold}

\texttt{unfold} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unfold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unfold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unfoldr}}{unfoldr}}\label{unfoldr}

\texttt{unfoldr} --- haskell list functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unfoldr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unfoldr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unfr}}{unfr}}\label{unfr}

\texttt{unfr} --- haskell list functions builtin. Alias for
\texttt{unfoldr}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unfr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unfr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unicode\_to\_native}}{unicode\_to\_native}}\label{unicode_to_native}

\texttt{unicode\_to\_native} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unicode\_to\_native $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unification\_robinson}}{unification\_robinson}}\label{unification_robinson}

\texttt{unification\_robinson} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unification\_robinson $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unification\_robinson |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{union\_list}}{union\_list}}\label{union_list}

\texttt{union\_list} --- additional missing stdlib functions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = union\_list $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map union\_list |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unionl}}{unionl}}\label{unionl}

\texttt{unionl} --- additional missing stdlib functions builtin. Alias
for \texttt{union\_list}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unionl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unionl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uniq\_by}}{uniq\_by}}\label{uniq_by}

\texttt{uniq\_by} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uniq\_by $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uniq\_by |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unique\_count}}{unique\_count}}\label{unique_count}

\texttt{unique\_count} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unique\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unique\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unique\_count\_of}}{unique\_count\_of}}\label{unique_count_of}

\texttt{unique\_count\_of} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unique\_count\_of $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unique\_count\_of |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unique\_words}}{unique\_words}}\label{unique_words}

\texttt{unique\_words} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unique\_words $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unique\_words |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uniqw}}{uniqw}}\label{uniqw}

\texttt{uniqw} --- string processing (uncategorized batch) builtin.
Alias for \texttt{unique\_words}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uniqw $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uniqw |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unit\_vec}}{unit\_vec}}\label{unit_vec}

\texttt{unit\_vec} --- matrix / linear algebra builtin. Alias for
\texttt{vec\_normalize}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unit\_vec $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unit\_vec |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unit\_vector}}{unit\_vector}}\label{unit_vector}

\texttt{unit\_vector} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unit\_vector $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unit\_vector |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{universal\_code\_length}}{universal\_code\_length}}\label{universal_code_length}

\texttt{universal\_code\_length} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = universal\_code\_length $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map universal\_code\_length |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{universal\_enveloping\_dim}}{universal\_enveloping\_dim}}\label{universal_enveloping_dim}

\texttt{universal\_enveloping\_dim} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = universal\_enveloping\_dim $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map universal\_enveloping\_dim |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unix\_epoch}}{unix\_epoch}}\label{unix_epoch}

\texttt{unix\_epoch} --- now / timestamp builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unix\_epoch $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unix\_epoch |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unix\_epoch\_ms}}{unix\_epoch\_ms}}\label{unix_epoch_ms}

\texttt{unix\_epoch\_ms} --- now / timestamp builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unix\_epoch\_ms $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unix\_epoch\_ms |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unix\_epoch\_to\_iso}}{unix\_epoch\_to\_iso}}\label{unix_epoch_to_iso}

\texttt{unix\_epoch\_to\_iso} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unix\_epoch\_to\_iso $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unlines}}{unlines}}\label{unlines}

\texttt{unlines} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unlines $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unlines |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unlns}}{unlns}}\label{unlns}

\texttt{unlns} --- go/general functional utilities builtin. Alias for
\texttt{unlines}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unlns $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unlns |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unquote}}{unquote}}\label{unquote}

\texttt{unquote} --- string quote / escape builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unquote $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unquote |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unruh\_temperature\_full}}{unruh\_temperature\_full}}\label{unruh_temperature_full}

\texttt{unruh\_temperature\_full} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unruh\_temperature\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unruh\_temperature\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unscented\_sigma\_point}}{unscented\_sigma\_point}}\label{unscented_sigma_point}

\texttt{unscented\_sigma\_point} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unscented\_sigma\_point $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unscented\_sigma\_point |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unsharp\_mask\_kernel}}{unsharp\_mask\_kernel}}\label{unsharp_mask_kernel}

\texttt{unsharp\_mask\_kernel} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unsharp\_mask\_kernel $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unsharp\_mask\_kernel |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unsharp\_mask\_step}}{unsharp\_mask\_step}}\label{unsharp_mask_step}

\texttt{unsharp\_mask\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unsharp\_mask\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unsharp\_mask\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{untie}}{untie}}\label{untie}

\texttt{untie} --- type / reflection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = untie $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map untie |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unwds}}{unwds}}\label{unwds}

\texttt{unwds} --- go/general functional utilities builtin. Alias for
\texttt{unwords}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unwds $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unwds |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unweaken}}{unweaken}}\label{unweaken}

\texttt{unweaken} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unweaken $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unweaken |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unwords}}{unwords}}\label{unwords}

\texttt{unwords} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unwords $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unwords |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unzip}}{unzip}}\label{unzip}

\texttt{unzip} --- collection more builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unzip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unzip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unzip\_archive}}{unzip\_archive}}\label{unzip_archive}

\texttt{unzip\_archive} --- crypto / encoding builtin. Alias for
\texttt{zip\_extract}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unzip\_archive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unzip\_archive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{unzip\_pairs}}{unzip\_pairs}}\label{unzip_pairs}

\texttt{unzip\_pairs} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = unzip\_pairs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map unzip\_pairs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upc\_check}}{upc\_check}}\label{upc_check}

\texttt{upc\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upc\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upc\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upcase\_each}}{upcase\_each}}\label{upcase_each}

\texttt{upcase\_each} --- trivial numeric helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upcase\_each $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upcase\_each |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upda}}{upda}}\label{upda}

\texttt{upda} --- go/general functional utilities builtin. Alias for
\texttt{update\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upda $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upda |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{update\_at}}{update\_at}}\label{update_at}

\texttt{update\_at} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = update\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map update\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{update\_in}}{update\_in}}\label{update_in}

\texttt{update\_in} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = update\_in $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map update\_in |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upfirdn\_step}}{upfirdn\_step}}\label{upfirdn_step}

\texttt{upfirdn\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upfirdn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upfirdn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upper\_bound}}{upper\_bound}}\label{upper_bound}

\texttt{upper\_bound} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upper\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upper\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upper\_snake}}{upper\_snake}}\label{upper_snake}

\texttt{upper\_snake} --- string (batch 2) builtin. Alias for
\texttt{constant\_case}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upper\_snake $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upper\_snake |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upper\_triangular\_q}}{upper\_triangular\_q}}\label{upper_triangular_q}

\texttt{upper\_triangular\_q} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upper\_triangular\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upper\_triangular\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uppercase}}{uppercase}}\label{uppercase}

\texttt{uppercase} --- string (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uppercase $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uppercase |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upsample}}{upsample}}\label{upsample}

\texttt{upsample(\textbackslash{}@signal,\ \$factor)} (alias
\texttt{interpolate}) --- increases sample rate by inserting zeros and
filtering. Factor must be positive integer.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $upsampled = interpolate(\textbackslash{}@signal, 4)  \# 4x sample rate}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uptime\_secs}}{uptime\_secs}}\label{uptime_secs}

\texttt{uptime\_secs} --- more process / system builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uptime\_secs $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uptime\_secs |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{upto}}{upto}}\label{upto}

\texttt{upto} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = upto $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map upto |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uqb}}{uqb}}\label{uqb}

\texttt{uqb} --- python/ruby stdlib builtin. Alias for
\texttt{uniq\_by}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uqb $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uqb |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uri\_normalize}}{uri\_normalize}}\label{uri_normalize}

\texttt{uri\_normalize} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uri\_normalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uri\_normalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uri\_resolve}}{uri\_resolve}}\label{uri_resolve}

\texttt{uri\_resolve} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uri\_resolve $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uri\_resolve |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uri\_template\_expand}}{uri\_template\_expand}}\label{uri_template_expand}

\texttt{uri\_template\_expand} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uri\_template\_expand $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uri\_template\_expand |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_decode\_form}}{url\_decode\_form}}\label{url_decode_form}

\texttt{url\_decode\_form} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_decode\_form $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_decode\_form |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_encode\_form}}{url\_encode\_form}}\label{url_encode_form}

\texttt{url\_encode\_form} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_encode\_form $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_encode\_form |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_host}}{url\_host}}\label{url_host}

\texttt{url\_host} --- url / email parts builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_host $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_host |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_origin}}{url\_origin}}\label{url_origin}

\texttt{url\_origin} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_origin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_origin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_path}}{url\_path}}\label{url_path}

\texttt{url\_path} --- url / email parts builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_path $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_path |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_query}}{url\_query}}\label{url_query}

\texttt{url\_query} --- url / email parts builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_query $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_query |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{url\_scheme}}{url\_scheme}}\label{url_scheme}

\texttt{url\_scheme} --- url / email parts builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = url\_scheme $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map url\_scheme |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{urld}}{urld}}\label{urld}

\texttt{urld} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = urld $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map urld |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{urle}}{urle}}\label{urle}

\texttt{urle} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = urle $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map urle |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{us\_to\_ns}}{us\_to\_ns}}\label{us_to_ns}

\texttt{us\_to\_ns} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = us\_to\_ns $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{usamp}}{usamp}}\label{usamp}

\texttt{usamp} --- dsp / signal (extended) builtin. Alias for
\texttt{upsample}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = usamp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map usamp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{username}}{username}}\label{username}

\texttt{username} --- system introspection builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = username $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map username |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{utc}}{utc}}\label{utc}

\texttt{utc} --- date / time builtin. Alias for \texttt{datetime\_utc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = utc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map utc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{utci\_simple}}{utci\_simple}}\label{utci_simple}

\texttt{utci\_simple} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = utci\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map utci\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{utilitarian\_solution}}{utilitarian\_solution}}\label{utilitarian_solution}

\texttt{utilitarian\_solution} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = utilitarian\_solution $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map utilitarian\_solution |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{utm\_from\_lat\_lng}}{utm\_from\_lat\_lng}}\label{utm_from_lat_lng}

\texttt{utm\_from\_lat\_lng} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = utm\_from\_lat\_lng $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map utm\_from\_lat\_lng |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{utm\_to\_lat\_lng}}{utm\_to\_lat\_lng}}\label{utm_to_lat_lng}

\texttt{utm\_to\_lat\_lng} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = utm\_to\_lat\_lng $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uuencode\_step}}{uuencode\_step}}\label{uuencode_step}

\texttt{uuencode\_step} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uuencode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uuencode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uuid\_v4}}{uuid\_v4}}\label{uuid_v4}

\texttt{uuid\_v4} --- id helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uuid\_v4 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uuid\_v4 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uzp}}{uzp}}\label{uzp}

\texttt{uzp} --- go/general functional utilities builtin. Alias for
\texttt{unzip\_pairs}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uzp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uzp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{uzst}}{uzst}}\label{uzst}

\texttt{uzst} --- crypto / encoding builtin. Alias for
\texttt{zstd\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = uzst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map uzst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{v\_polynomial\_eval}}{v\_polynomial\_eval}}\label{v_polynomial_eval}

\texttt{v\_polynomial\_eval} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = v\_polynomial\_eval $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map v\_polynomial\_eval |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vaccination\_coverage\_required}}{vaccination\_coverage\_required}}\label{vaccination_coverage_required}

\texttt{vaccination\_coverage\_required} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vaccination\_coverage\_required $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vaccination\_coverage\_required |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vacuum\_energy\_density}}{vacuum\_energy\_density}}\label{vacuum_energy_density}

\texttt{vacuum\_energy\_density} --- batch 31 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vacuum\_energy\_density $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vacuum\_energy\_density |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vacuum\_permeability}}{vacuum\_permeability}}\label{vacuum_permeability}

\texttt{vacuum\_permeability} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vacuum\_permeability $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vacuum\_permeability |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{value\_iteration\_step}}{value\_iteration\_step}}\label{value_iteration_step}

\texttt{value\_iteration\_step} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = value\_iteration\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map value\_iteration\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{values\_at}}{values\_at}}\label{values_at}

\texttt{values\_at} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = values\_at $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map values\_at |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{values\_sorted}}{values\_sorted}}\label{values_sorted}

\texttt{values\_sorted} --- hash ops (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = values\_sorted $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map values\_sorted |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{van\_leer\_limiter}}{van\_leer\_limiter}}\label{van_leer_limiter}

\texttt{van\_leer\_limiter} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = van\_leer\_limiter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map van\_leer\_limiter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{van\_t\_hoff\_kp}}{van\_t\_hoff\_kp}}\label{van_t_hoff_kp}

\texttt{van\_t\_hoff\_kp} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = van\_t\_hoff\_kp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map van\_t\_hoff\_kp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vang}}{vang}}\label{vang}

\texttt{vang} --- geometry (extended) builtin. Alias for
\texttt{vector\_angle}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vang $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vang |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vant\_hoff}}{vant\_hoff}}\label{vant_hoff}

\texttt{vant\_hoff} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vant\_hoff $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vant\_hoff |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{var\_fit}}{var\_fit}}\label{var_fit}

\texttt{var\_fit} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = var\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map var\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{var\_historical}}{var\_historical}}\label{var_historical}

\texttt{var\_historical} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = var\_historical $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map var\_historical |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{variance\_decomposition}}{variance\_decomposition}}\label{variance_decomposition}

\texttt{variance\_decomposition} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = variance\_decomposition $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map variance\_decomposition |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vary\_match}}{vary\_match}}\label{vary_match}

\texttt{vary\_match} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vary\_match $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vary\_match |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vasicek\_bond}}{vasicek\_bond}}\label{vasicek_bond}

\texttt{vasicek\_bond} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vasicek\_bond $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vasicek\_bond |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vat}}{vat}}\label{vat}

\texttt{vat} --- python/ruby stdlib builtin. Alias for
\texttt{values\_at}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vcg\_payment}}{vcg\_payment}}\label{vcg_payment}

\texttt{vcg\_payment} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vcg\_payment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vcg\_payment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vcg\_payment\_step}}{vcg\_payment\_step}}\label{vcg_payment_step}

\texttt{vcg\_payment\_step} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vcg\_payment\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vcg\_payment\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vcross}}{vcross}}\label{vcross}

\texttt{vector\_cross(\textbackslash{}@a,\ \textbackslash{}@b)} (alias
\texttt{vcross}) --- computes the cross product of two 3D vectors.
Returns a 3-element arrayref perpendicular to both inputs.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $c = vcross([1,0,0], [0,1,0])}
\NormalTok{p @$c   \# (0, 0, 1)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vdot}}{vdot}}\label{vdot}

\texttt{vector\_dot(\textbackslash{}@a,\ \textbackslash{}@b)} (alias
\texttt{vdot}) --- computes the dot product of two vectors. Returns the
scalar sum of element-wise products.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p vdot([1,2,3], [4,5,6])   \# 32}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_add}}{vec\_add}}\label{vec_add}

\texttt{vec\_add} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_add $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_add |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_clj}}{vec\_clj}}\label{vec_clj}

\texttt{vec\_clj} --- algebraic match builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_clj $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_clj |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_dot}}{vec\_dot}}\label{vec_dot}

\texttt{vec\_dot} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_dot $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_dot |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_l2}}{vec\_l2}}\label{vec_l2}

\texttt{vec\_l2} --- batch 11 builtin. Alias for \texttt{l2\_norm}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_l2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_l2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_normalize}}{vec\_normalize}}\label{vec_normalize}

\texttt{vec\_normalize} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_normalize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_normalize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_outer}}{vec\_outer}}\label{vec_outer}

\texttt{vec\_outer} --- batch 11 builtin. Alias for
\texttt{outer\_product}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_outer $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_outer |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_scale}}{vec\_scale}}\label{vec_scale}

\texttt{vec\_scale} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_scale $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_scale |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_set\_value}}{vec\_set\_value}}\label{vec_set_value}

\texttt{vec\_set\_value} --- internal builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_set\_value $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_set\_value |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vec\_sub}}{vec\_sub}}\label{vec_sub}

\texttt{vec\_sub} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vec\_sub $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vec\_sub |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vecc}}{vecc}}\label{vecc}

\texttt{vecc} --- algebraic match builtin. Alias for \texttt{vec\_clj}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vecc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vecc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vecm\_alpha\_beta}}{vecm\_alpha\_beta}}\label{vecm_alpha_beta}

\texttt{vecm\_alpha\_beta} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vecm\_alpha\_beta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vecm\_alpha\_beta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vecm\_fit}}{vecm\_fit}}\label{vecm_fit}

\texttt{vecm\_fit} --- batch 78 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vecm\_fit $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vecm\_fit |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vector\_angle}}{vector\_angle}}\label{vector_angle}

\texttt{vector\_angle(\textbackslash{}@a,\ \textbackslash{}@b)} (alias
\texttt{vangle}) --- computes the angle in radians between two vectors
using the dot product formula.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p vangle([1,0], [0,1])   \# \textasciitilde{}1.5708 (π/2)}
\NormalTok{p vangle([1,0], [1,0])   \# 0}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vector\_magnitude}}{vector\_magnitude}}\label{vector_magnitude}

\texttt{vector\_magnitude(\textbackslash{}@v)} (alias \texttt{vmag}) ---
computes the Euclidean length (L2 norm) of a vector.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p vmag([3, 4])   \# 5}
\NormalTok{p vmag([1, 2, 2])   \# 3}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vector\_normalize}}{vector\_normalize}}\label{vector_normalize}

\texttt{vector\_normalize(\textbackslash{}@v)} (alias \texttt{vnorm})
--- returns a unit vector in the same direction. Divides by magnitude.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $u = vnorm([3, 4])}
\NormalTok{p @$u   \# (0.6, 0.8)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vector\_project}}{vector\_project}}\label{vector_project}

\texttt{vector\_project} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vector\_project $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vector\_project |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vector\_reject}}{vector\_reject}}\label{vector_reject}

\texttt{vector\_reject} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vector\_reject $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vector\_reject |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{velocity\_potential\_step}}{velocity\_potential\_step}}\label{velocity_potential_step}

\texttt{velocity\_potential\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = velocity\_potential\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map velocity\_potential\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{verlinde\_count\_step}}{verlinde\_count\_step}}\label{verlinde_count_step}

\texttt{verlinde\_count\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = verlinde\_count\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map verlinde\_count\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{verma\_character\_step}}{verma\_character\_step}}\label{verma_character_step}

\texttt{verma\_character\_step} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = verma\_character\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map verma\_character\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{verner\_8\_combine}}{verner\_8\_combine}}\label{verner_8_combine}

\texttt{verner\_8\_combine} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = verner\_8\_combine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map verner\_8\_combine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{versin}}{versin}}\label{versin}

\texttt{versin} --- trig extensions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = versin $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map versin |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{versine}}{versine}}\label{versine}

\texttt{versine} --- trig extensions builtin. Alias for \texttt{versin}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = versine $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map versine |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{version\_cmp}}{version\_cmp}}\label{version_cmp}

\texttt{version\_cmp} --- file stat / path builtin. Alias for
\texttt{compare\_versions}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = version\_cmp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map version\_cmp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vertex\_connectivity}}{vertex\_connectivity}}\label{vertex_connectivity}

\texttt{vertex\_connectivity} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vertex\_connectivity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vertex\_connectivity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vertex\_cover\_lp\_round}}{vertex\_cover\_lp\_round}}\label{vertex_cover_lp_round}

\texttt{vertex\_cover\_lp\_round} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vertex\_cover\_lp\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vertex\_cover\_lp\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vf2\_consistent}}{vf2\_consistent}}\label{vf2_consistent}

\texttt{vf2\_consistent} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vf2\_consistent $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vf2\_consistent |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vickrey\_auction}}{vickrey\_auction}}\label{vickrey_auction}

\texttt{vickrey\_auction} --- batch 73 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vickrey\_auction $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vickrey\_auction |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vigenere\_decrypt}}{vigenere\_decrypt}}\label{vigenere_decrypt}

\texttt{vigenere\_decrypt} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vigenere\_decrypt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vigenere\_decrypt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vigenere\_encrypt}}{vigenere\_encrypt}}\label{vigenere_encrypt}

\texttt{vigenere\_encrypt} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vigenere\_encrypt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vigenere\_encrypt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vin\_check}}{vin\_check}}\label{vin_check}

\texttt{vin\_check} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vin\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vin\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vincenty\_dist}}{vincenty\_dist}}\label{vincenty_dist}

\texttt{vincenty\_dist} --- batch 58 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vincenty\_dist $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vincenty\_dist |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{virtual\_temperature\_full}}{virtual\_temperature\_full}}\label{virtual_temperature_full}

\texttt{virtual\_temperature\_full} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = virtual\_temperature\_full $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map virtual\_temperature\_full |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{viterbi\_pos\_tag}}{viterbi\_pos\_tag}}\label{viterbi_pos_tag}

\texttt{viterbi\_pos\_tag} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = viterbi\_pos\_tag $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map viterbi\_pos\_tag |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vlookup}}{vlookup}}\label{vlookup}

\texttt{vlookup} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vlookup $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vlookup |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vo2\_max\_estimate}}{vo2\_max\_estimate}}\label{vo2_max_estimate}

\texttt{vo2\_max\_estimate} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vo2\_max\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vo2\_max\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{void}}{void}}\label{void}

\texttt{void} --- conversion / utility (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = void $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map void |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{voigt\_profile}}{voigt\_profile}}\label{voigt_profile}

\texttt{voigt\_profile} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = voigt\_profile $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map voigt\_profile |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{voigt\_profile\_simple}}{voigt\_profile\_simple}}\label{voigt_profile_simple}

\texttt{voigt\_profile\_simple} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = voigt\_profile\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map voigt\_profile\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{voltage\_divider}}{voltage\_divider}}\label{voltage_divider}

\texttt{voltage\_divider} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = voltage\_divider $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map voltage\_divider |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{voltaic\_efficiency}}{voltaic\_efficiency}}\label{voltaic_efficiency}

\texttt{voltaic\_efficiency} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = voltaic\_efficiency $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map voltaic\_efficiency |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{volume\_form\_riemannian}}{volume\_form\_riemannian}}\label{volume_form_riemannian}

\texttt{volume\_form\_riemannian} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = volume\_form\_riemannian $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map volume\_form\_riemannian |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vqe\_step}}{vqe\_step}}\label{vqe_step}

\texttt{vqe\_step} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vqe\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vqe\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{vsepr\_geometry}}{vsepr\_geometry}}\label{vsepr_geometry}

\texttt{vsepr\_geometry} --- batch 63 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = vsepr\_geometry $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map vsepr\_geometry |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{w\_state}}{w\_state}}\label{w_state}

\texttt{w\_state} --- batch 80 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = w\_state $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map w\_state |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{w\_state\_n}}{w\_state\_n}}\label{w_state_n}

\texttt{w\_state\_n} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = w\_state\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map w\_state\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wacc}}{wacc}}\label{wacc}

\texttt{wacc(\$equity,\ \$debt,\ \$cost\_equity,\ \$cost\_debt,\ \$tax\_rate)}
--- computes Weighted Average Cost of Capital. Returns the blended cost
of capital accounting for the tax shield on debt.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p wacc(60, 40, 0.10, 0.05, 0.25)   \# \textasciitilde{}7.5\%}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wald\_test\_stat}}{wald\_test\_stat}}\label{wald_test_stat}

\texttt{wald\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wald\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wald\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{walden\_product}}{walden\_product}}\label{walden_product}

\texttt{walden\_product} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = walden\_product $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map walden\_product |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{walker\_circulation\_step}}{walker\_circulation\_step}}\label{walker_circulation_step}

\texttt{walker\_circulation\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = walker\_circulation\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map walker\_circulation\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{walksat\_step}}{walksat\_step}}\label{walksat_step}

\texttt{walksat\_step} --- batch 67 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = walksat\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map walksat\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{war\_above\_replacement}}{war\_above\_replacement}}\label{war_above_replacement}

\texttt{war\_above\_replacement} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = war\_above\_replacement $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map war\_above\_replacement |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{warburg\_impedance}}{warburg\_impedance}}\label{warburg_impedance}

\texttt{warburg\_impedance} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = warburg\_impedance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map warburg\_impedance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{warped\_product\_step\_zero}}{warped\_product\_step\_zero}}\label{warped_product_step_zero}

\texttt{warped\_product\_step\_zero} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = warped\_product\_step\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map warped\_product\_step\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{warshall\_step}}{warshall\_step}}\label{warshall_step}

\texttt{warshall\_step} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = warshall\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map warshall\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wasserstein\_dist\_emp}}{wasserstein\_dist\_emp}}\label{wasserstein_dist_emp}

\texttt{wasserstein\_dist\_emp} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wasserstein\_dist\_emp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wasserstein\_dist\_emp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{watershed\_segment}}{watershed\_segment}}\label{watershed_segment}

\texttt{watershed\_segment} --- batch 77 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = watershed\_segment $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map watershed\_segment |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wattersons\_theta}}{wattersons\_theta}}\label{wattersons_theta}

\texttt{wattersons\_theta} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wattersons\_theta $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wattersons\_theta |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{watts\_to\_hp}}{watts\_to\_hp}}\label{watts_to_hp}

\texttt{watts\_to\_hp} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = watts\_to\_hp $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wave\_string\_speed}}{wave\_string\_speed}}\label{wave_string_speed}

\texttt{wave\_string\_speed} --- batch 23 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wave\_string\_speed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wave\_string\_speed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wavelength\_freq}}{wavelength\_freq}}\label{wavelength_freq}

\texttt{wavelength\_freq} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wavelength\_freq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wavelength\_freq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wc}}{wc}}\label{wc}

\texttt{wc} --- trivial string ops builtin. Alias for
\texttt{word\_count}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wcag\_contrast}}{wcag\_contrast}}\label{wcag_contrast}

\texttt{wcag\_contrast} --- batch 9 builtin. Alias for
\texttt{contrast\_ratio\_wcag}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wcag\_contrast $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wcag\_contrast |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wcag\_luminance}}{wcag\_luminance}}\label{wcag_luminance}

\texttt{wcag\_luminance} --- batch 9 builtin. Alias for
\texttt{relative\_luminance}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wcag\_luminance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wcag\_luminance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wcag\_pass}}{wcag\_pass}}\label{wcag_pass}

\texttt{wcag\_pass} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wcag\_pass $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wcag\_pass |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wcount}}{wcount}}\label{wcount}

\texttt{wcount} --- extended stdlib batch 3 builtin. Alias for
\texttt{count\_words}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weak\_composition\_count}}{weak\_composition\_count}}\label{weak_composition_count}

\texttt{weak\_composition\_count} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weak\_composition\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weak\_composition\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weaken}}{weaken}}\label{weaken}

\texttt{weaken} --- list / aggregate builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weaken $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weaken |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weber\_number}}{weber\_number}}\label{weber_number}

\texttt{weber\_number} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weber\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weber\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weber\_number\_step}}{weber\_number\_step}}\label{weber_number_step}

\texttt{weber\_number\_step} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weber\_number\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weber\_number\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{week\_number\_iso}}{week\_number\_iso}}\label{week_number_iso}

\texttt{week\_number\_iso} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = week\_number\_iso $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map week\_number\_iso |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{week\_of\_year}}{week\_of\_year}}\label{week_of_year}

\texttt{week\_of\_year} --- extended stdlib batch 3 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = week\_of\_year $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map week\_of\_year |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weekday\_name}}{weekday\_name}}\label{weekday_name}

\texttt{weekday\_name} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weekday\_name $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weekday\_name |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weekday\_name\_short}}{weekday\_name\_short}}\label{weekday_name_short}

\texttt{weekday\_name\_short} --- batch 52 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weekday\_name\_short $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weekday\_name\_short |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weekday\_short}}{weekday\_short}}\label{weekday_short}

\texttt{weekday\_short} --- date helpers builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weekday\_short $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weekday\_short |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weeks\_between}}{weeks\_between}}\label{weeks_between}

\texttt{weeks\_between} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weeks\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weeks\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weibpdf}}{weibpdf}}\label{weibpdf}

\texttt{weibull\_pdf} (alias \texttt{weibpdf}) evaluates the Weibull
distribution PDF at x with shape k and scale lambda.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p weibpdf(1.0, 1.5, 1.0)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weighted\_match\_kuhn\_step}}{weighted\_match\_kuhn\_step}}\label{weighted_match_kuhn_step}

\texttt{weighted\_match\_kuhn\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weighted\_match\_kuhn\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weighted\_match\_kuhn\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weighted\_mean}}{weighted\_mean}}\label{weighted_mean}

\texttt{weighted\_mean} --- math / numeric (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weighted\_mean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weighted\_mean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weighted\_sample}}{weighted\_sample}}\label{weighted_sample}

\texttt{weighted\_sample} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weighted\_sample $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weighted\_sample |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weighted\_set\_cover\_step}}{weighted\_set\_cover\_step}}\label{weighted_set_cover_step}

\texttt{weighted\_set\_cover\_step} --- batch 41 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weighted\_set\_cover\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weighted\_set\_cover\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weighted\_var}}{weighted\_var}}\label{weighted_var}

\texttt{weighted\_var} --- weighted variance. Args: values, weights.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p wvar([1,2,3,4], [1,1,1,1])  \# same as var}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weingarten\_map\_step}}{weingarten\_map\_step}}\label{weingarten_map_step}

\texttt{weingarten\_map\_step} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weingarten\_map\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weingarten\_map\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{welch\_psd\_avg}}{welch\_psd\_avg}}\label{welch_psd_avg}

\texttt{welch\_psd\_avg} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = welch\_psd\_avg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map welch\_psd\_avg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{welch\_ttest}}{welch\_ttest}}\label{welch_ttest}

\texttt{welch\_ttest} (alias \texttt{welcht}) performs
Welch\textquotesingle s t-test for two independent samples with unequal
variances. Returns {[}t-statistic, degrees of freedom{]}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my ($t, $df) = @\{welcht([1,2,3,4,5], [3,4,5,6,7])\}}
\NormalTok{p "t=$t df=$df"}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{welch\_window}}{welch\_window}}\label{welch_window}

\texttt{welch\_window} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = welch\_window $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map welch\_window |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{welsh\_powell}}{welsh\_powell}}\label{welsh_powell}

\texttt{welsh\_powell} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = welsh\_powell $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map welsh\_powell |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{werckmeister\_iii}}{werckmeister\_iii}}\label{werckmeister_iii}

\texttt{werckmeister\_iii} --- batch 64 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = werckmeister\_iii $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map werckmeister\_iii |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{westerlies\_jet\_speed}}{westerlies\_jet\_speed}}\label{westerlies_jet_speed}

\texttt{westerlies\_jet\_speed} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = westerlies\_jet\_speed $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map westerlies\_jet\_speed |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wet\_bulb\_potential}}{wet\_bulb\_potential}}\label{wet_bulb_potential}

\texttt{wet\_bulb\_potential} --- batch 42 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wet\_bulb\_potential $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wet\_bulb\_potential |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weyl\_group\_order}}{weyl\_group\_order}}\label{weyl_group_order}

\texttt{weyl\_group\_order} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weyl\_group\_order $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weyl\_group\_order |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{weyl\_tensor\_step\_zero}}{weyl\_tensor\_step\_zero}}\label{weyl_tensor_step_zero}

\texttt{weyl\_tensor\_step\_zero} --- batch 39 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = weyl\_tensor\_step\_zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map weyl\_tensor\_step\_zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wfrm}}{wfrm}}\label{wfrm}

\texttt{wfrm} --- go/general functional utilities builtin. Alias for
\texttt{words\_from}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wfrm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wfrm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wh}}{wh}}\label{wh}

\texttt{wh} --- filesystem extensions builtin. Alias for \texttt{which}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wh $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wh |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wha}}{wha}}\label{wha}

Return a list of all absolute paths matching the given command name
across every directory in \texttt{PATH}, not just the first match. The
short alias \texttt{wha} keeps things concise. This is useful for
detecting shadowed executables or auditing which versions of a tool are
installed.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @all = which\_all("python3")}
\NormalTok{@all |\textgreater{} e p                \# /usr/local/bin/python3}
\NormalTok{                             \# /usr/bin/python3}
\NormalTok{p scalar wha("perl")        \# number of perls on PATH}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{when\_false}}{when\_false}}\label{when_false}

\texttt{when\_false} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = when\_false $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map when\_false |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{when\_true}}{when\_true}}\label{when_true}

\texttt{when\_true} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = when\_true $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map when\_true |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{which\_fn}}{which\_fn}}\label{which_fn}

\texttt{which\_fn} --- return indices where a predicate is true. Like
R\textquotesingle s which().

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @idx = @\{which\_fn([1,5,3,8,2], fn \{ $\_[0] \textgreater{} 3 \})\}  \# [1, 3]}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{white}}{white}}\label{white}

\texttt{white} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = white $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map white |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{white\_bold}}{white\_bold}}\label{white_bold}

\texttt{white\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = white\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map white\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{white\_robust\_se}}{white\_robust\_se}}\label{white_robust_se}

\texttt{white\_robust\_se} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = white\_robust\_se $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map white\_robust\_se |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{white\_test\_stat}}{white\_test\_stat}}\label{white_test_stat}

\texttt{white\_test\_stat} --- batch 36 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = white\_test\_stat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map white\_test\_stat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{whittaker\_m}}{whittaker\_m}}\label{whittaker_m}

\texttt{whittaker\_m} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = whittaker\_m $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map whittaker\_m |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{whole\_life\_a}}{whole\_life\_a}}\label{whole_life_a}

\texttt{whole\_life\_a} --- batch 60 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = whole\_life\_a $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map whole\_life\_a |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wieferich\_check}}{wieferich\_check}}\label{wieferich_check}

\texttt{wieferich\_check} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wieferich\_check $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wieferich\_check |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wien}}{wien}}\label{wien}

\texttt{wien} --- physics formulas builtin. Alias for
\texttt{wien\_displacement}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wien $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wien |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wien\_constant}}{wien\_constant}}\label{wien_constant}

\texttt{wien\_constant} --- physics constants builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wien\_constant $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wien\_constant |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wien\_displacement}}{wien\_displacement}}\label{wien_displacement}

\texttt{wien\_displacement} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wien\_displacement $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wien\_displacement |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wiener\_filter}}{wiener\_filter}}\label{wiener_filter}

\texttt{wiener\_filter} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wiener\_filter $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wiener\_filter |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wigner\_3j\_bound}}{wigner\_3j\_bound}}\label{wigner_3j_bound}

\texttt{wigner\_3j\_bound} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wigner\_3j\_bound $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wigner\_3j\_bound |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wilcoxon}}{wilcoxon}}\label{wilcoxon}

\texttt{wilcoxon} --- batch 53 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wilcoxon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wilcoxon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wilson\_test}}{wilson\_test}}\label{wilson_test}

\texttt{wilson\_test} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wilson\_test $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wilson\_test |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wilson\_theta\_step}}{wilson\_theta\_step}}\label{wilson_theta_step}

\texttt{wilson\_theta\_step} --- batch 34 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wilson\_theta\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wilson\_theta\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{win\_probability}}{win\_probability}}\label{win_probability}

\texttt{win\_probability} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = win\_probability $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map win\_probability |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wincirc}}{wincirc}}\label{wincirc}

\texttt{wincirc} --- additional missing stdlib functions builtin. Alias
for \texttt{windowed\_circular}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wincirc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wincirc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wind\_chill}}{wind\_chill}}\label{wind_chill}

\texttt{wind\_chill} --- physics formulas builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wind\_chill $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wind\_chill |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wind\_chill\_celsius}}{wind\_chill\_celsius}}\label{wind_chill_celsius}

\texttt{wind\_chill\_celsius} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wind\_chill\_celsius $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wind\_chill\_celsius |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{window\_n}}{window\_n}}\label{window_n}

\texttt{window\_n} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = window\_n $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map window\_n |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{windowed\_circular}}{windowed\_circular}}\label{windowed_circular}

\texttt{windowed\_circular} --- additional missing stdlib functions
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = windowed\_circular $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map windowed\_circular |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{winn}}{winn}}\label{winn}

\texttt{winn} --- go/general functional utilities builtin. Alias for
\texttt{window\_n}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = winn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map winn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{winsor}}{winsor}}\label{winsor}

\texttt{winsor} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{winsorize}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = winsor $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map winsor |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{winsorize}}{winsorize}}\label{winsorize}

\texttt{winsorize} --- math / numeric (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = winsorize $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map winsorize |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{winsorized\_variance\_arr}}{winsorized\_variance\_arr}}\label{winsorized_variance_arr}

\texttt{winsorized\_variance\_arr} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = winsorized\_variance\_arr $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map winsorized\_variance\_arr |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wire\_resistance}}{wire\_resistance}}\label{wire_resistance}

\texttt{wire\_resistance} --- batch 12 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wire\_resistance $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wire\_resistance |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{without}}{without}}\label{without}

\texttt{without} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = without $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map without |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{without\_nth}}{without\_nth}}\label{without_nth}

\texttt{without\_nth} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = without\_nth $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map without\_nth |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wmean}}{wmean}}\label{wmean}

\texttt{wmean} --- math / numeric (uncategorized batch) builtin. Alias
for \texttt{weighted\_mean}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wmean $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wmean |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{woba\_weight}}{woba\_weight}}\label{woba_weight}

\texttt{woba\_weight} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = woba\_weight $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map woba\_weight |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wofz}}{wofz}}\label{wofz}

\texttt{wofz} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wofz $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wofz |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wolfe\_strong\_q}}{wolfe\_strong\_q}}\label{wolfe_strong_q}

\texttt{wolfe\_strong\_q} --- batch 19 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wolfe\_strong\_q $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wolfe\_strong\_q |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{woodall\_number}}{woodall\_number}}\label{woodall_number}

\texttt{woodall\_number} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = woodall\_number $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map woodall\_number |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_alignment\_ibm1}}{word\_alignment\_ibm1}}\label{word_alignment_ibm1}

\texttt{word\_alignment\_ibm1} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_alignment\_ibm1 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_alignment\_ibm1 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_alignment\_ibm2}}{word\_alignment\_ibm2}}\label{word_alignment_ibm2}

\texttt{word\_alignment\_ibm2} --- batch 69 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_alignment\_ibm2 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_alignment\_ibm2 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_count}}{word\_count}}\label{word_count}

\texttt{word\_count} --- trivial string ops builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_count\_simple}}{word\_count\_simple}}\label{word_count_simple}

\texttt{word\_count\_simple} --- batch 11 builtin. Alias for
\texttt{string\_words\_count}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_count\_simple $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_count\_simple |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_frequencies}}{word\_frequencies}}\label{word_frequencies}

\texttt{word\_frequencies} --- string processing (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_frequencies $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_frequencies |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_similarity}}{word\_similarity}}\label{word_similarity}

\texttt{word\_similarity} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_similarity $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_similarity |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{word\_wrap\_text}}{word\_wrap\_text}}\label{word_wrap_text}

\texttt{word\_wrap\_text} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = word\_wrap\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map word\_wrap\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wordfreq}}{wordfreq}}\label{wordfreq}

\texttt{wordfreq} --- string processing (uncategorized batch) builtin.
Alias for \texttt{word\_frequencies}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wordfreq $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wordfreq |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{words\_from}}{words\_from}}\label{words_from}

\texttt{words\_from} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = words\_from $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map words\_from |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{work}}{work}}\label{work}

\texttt{work(\$force,\ \$distance,\ \$angle)} --- compute work W =
F×d×cos(θ) (Joules). Angle in degrees, default 0.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{p work(100, 10)       \# 1000 J (force parallel to motion)}
\NormalTok{p work(100, 10, 60)   \# 500 J (force at 60°)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{woy}}{woy}}\label{woy}

\texttt{woy} --- extended stdlib batch 3 builtin. Alias for
\texttt{week\_of\_year}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = woy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map woy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wpa}}{wpa}}\label{wpa}

\texttt{wpa} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wpa $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wpa |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrap\_around}}{wrap\_around}}\label{wrap_around}

\texttt{wrap\_around} --- trig / math (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrap\_around $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrap\_around |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrap\_index}}{wrap\_index}}\label{wrap_index}

\texttt{wrap\_index} --- list helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrap\_index $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrap\_index |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrap\_range}}{wrap\_range}}\label{wrap_range}

\texttt{wrap\_range} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrap\_range $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrap\_range |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrap\_text}}{wrap\_text}}\label{wrap_text}

\texttt{wrap\_text} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrap\_text $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrap\_text |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrc\_plus}}{wrc\_plus}}\label{wrc_plus}

\texttt{wrc\_plus} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrc\_plus $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrc\_plus |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wright\_omega}}{wright\_omega}}\label{wright_omega}

\texttt{wright\_omega} --- batch 29 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wright\_omega $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wright\_omega |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{writhe\_polygon}}{writhe\_polygon}}\label{writhe_polygon}

\texttt{writhe\_polygon} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = writhe\_polygon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map writhe\_polygon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrprng}}{wrprng}}\label{wrprng}

\texttt{wrprng} --- extended stdlib builtin. Alias for
\texttt{wrap\_range}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrprng $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrprng |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wrpt}}{wrpt}}\label{wrpt}

\texttt{wrpt} --- extended stdlib builtin. Alias for
\texttt{wrap\_text}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wrpt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wrpt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wsamp}}{wsamp}}\label{wsamp}

\texttt{wsamp} --- extended stdlib builtin. Alias for
\texttt{weighted\_sample}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wsamp $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wsamp |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wwrap}}{wwrap}}\label{wwrap}

\texttt{wwrap} --- extended stdlib builtin. Alias for
\texttt{word\_wrap\_text}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wwrap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wwrap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{www\_auth\_parse}}{www\_auth\_parse}}\label{www_auth_parse}

\texttt{www\_auth\_parse} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = www\_auth\_parse $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map www\_auth\_parse |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wyhash\_mix}}{wyhash\_mix}}\label{wyhash_mix}

\texttt{wyhash\_mix} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wyhash\_mix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wyhash\_mix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{wynn\_epsilon}}{wynn\_epsilon}}\label{wynn_epsilon}

\texttt{wynn\_epsilon} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = wynn\_epsilon $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map wynn\_epsilon |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{x25519\_field\_mul}}{x25519\_field\_mul}}\label{x25519_field_mul}

\texttt{x25519\_field\_mul} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = x25519\_field\_mul $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map x25519\_field\_mul |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xadd}}{xadd}}\label{xadd}

\texttt{xadd} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xadd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xadd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xd}}{xd}}\label{xd}

\texttt{xd} --- serialization (stryke-only encoders) builtin. Alias for
\texttt{xml\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xe}}{xe}}\label{xe}

\texttt{xe} --- serialization (stryke-only encoders) builtin. Alias for
\texttt{xml\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xe $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xe |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xentropy}}{xentropy}}\label{xentropy}

\texttt{xentropy} --- math / numeric (uncategorized batch) builtin.
Alias for \texttt{cross\_entropy}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xentropy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xentropy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xfip}}{xfip}}\label{xfip}

\texttt{xfip} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xfip $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xfip |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xirr}}{xirr}}\label{xirr}

\texttt{xirr(\textbackslash{}@cashflows,\ \textbackslash{}@dates)} ---
computes IRR for irregularly-spaced cash flows. Dates can be epoch
timestamps or date strings. More accurate than \texttt{irr} for
real-world investments.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @cf = ({-}1000, 500, 600)}
\NormalTok{my @dates = (\textquotesingle{}2020{-}01{-}01\textquotesingle{}, \textquotesingle{}2020{-}07{-}01\textquotesingle{}, \textquotesingle{}2021{-}01{-}01\textquotesingle{})}
\NormalTok{p xirr(\textbackslash{}@cf, \textbackslash{}@dates)}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xlen}}{xlen}}\label{xlen}

\texttt{xlen} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xlen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xlen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xlookup}}{xlookup}}\label{xlookup}

\texttt{xlookup} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xlookup $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xlookup |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xmlagg}}{xmlagg}}\label{xmlagg}

\texttt{xmlagg} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xmlagg $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xmlagg |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xmlforest}}{xmlforest}}\label{xmlforest}

\texttt{xmlforest} --- batch 70 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xmlforest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xmlforest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xnpv}}{xnpv}}\label{xnpv}

\texttt{xnpv} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xnpv $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xnpv |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xor\_bool}}{xor\_bool}}\label{xor_bool}

\texttt{xor\_bool} --- boolean combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xor\_bool $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xor\_bool |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xor\_break\_singlebyte}}{xor\_break\_singlebyte}}\label{xor_break_singlebyte}

\texttt{xor\_break\_singlebyte} --- batch 35 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xor\_break\_singlebyte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xor\_break\_singlebyte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xor\_brute\_keylen}}{xor\_brute\_keylen}}\label{xor_brute_keylen}

\texttt{xor\_brute\_keylen} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xor\_brute\_keylen $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xor\_brute\_keylen |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xor\_byte\_string}}{xor\_byte\_string}}\label{xor_byte_string}

\texttt{xor\_byte\_string} --- batches 17-18 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xor\_byte\_string $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xor\_byte\_string |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xor\_cipher\_byte}}{xor\_cipher\_byte}}\label{xor_cipher_byte}

\texttt{xor\_cipher\_byte} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xor\_cipher\_byte $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xor\_cipher\_byte |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xor\_strings}}{xor\_strings}}\label{xor_strings}

\texttt{xor\_strings} --- string helpers (batch 4) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xor\_strings $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xor\_strings |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xorshift32}}{xorshift32}}\label{xorshift32}

\texttt{xorshift32} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xorshift32 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xorshift32 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xorshift32\_step}}{xorshift32\_step}}\label{xorshift32_step}

\texttt{xorshift32\_step} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xorshift32\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xorshift32\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xorshift64}}{xorshift64}}\label{xorshift64}

\texttt{xorshift64} --- batch 26 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xorshift64 $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xorshift64 |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xrange}}{xrange}}\label{xrange}

\texttt{xrange} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xrange $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xrange |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xtea\_round}}{xtea\_round}}\label{xtea_round}

\texttt{xtea\_round} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xtea\_round $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map xtea\_round |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xyz\_to\_lab}}{xyz\_to\_lab}}\label{xyz_to_lab}

\texttt{xyz\_to\_lab} --- batch 30 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xyz\_to\_lab $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{xyz\_to\_rgb}}{xyz\_to\_rgb}}\label{xyz_to_rgb}

\texttt{xyz\_to\_rgb} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = xyz\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yamanouchi\_word\_count}}{yamanouchi\_word\_count}}\label{yamanouchi_word_count}

\texttt{yamanouchi\_word\_count} --- batch 37 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yamanouchi\_word\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yamanouchi\_word\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yards\_per\_attempt}}{yards\_per\_attempt}}\label{yards_per_attempt}

\texttt{yards\_per\_attempt} --- batch 56 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yards\_per\_attempt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yards\_per\_attempt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yards\_to\_m}}{yards\_to\_m}}\label{yards_to_m}

\texttt{yards\_to\_m} --- unit conversions builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yards\_to\_m $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yd}}{yd}}\label{yd}

\texttt{yd} --- serialization (stryke-only encoders) builtin. Alias for
\texttt{yaml\_decode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ye}}{ye}}\label{ye}

\texttt{ye} --- serialization (stryke-only encoders) builtin. Alias for
\texttt{yaml\_encode}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ye $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ye |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{years\_between}}{years\_between}}\label{years_between}

\texttt{years\_between} --- batch 9 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = years\_between $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map years\_between |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yellow}}{yellow}}\label{yellow}

\texttt{yellow} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yellow $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yellow |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yellow\_bold}}{yellow\_bold}}\label{yellow_bold}

\texttt{yellow\_bold} --- color / ansi builtin. Alias for \texttt{red}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yellow\_bold $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yellow\_bold |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yen\_k\_shortest}}{yen\_k\_shortest}}\label{yen_k_shortest}

\texttt{yen\_k\_shortest} --- batch 75 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yen\_k\_shortest $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yen\_k\_shortest |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yesterday}}{yesterday}}\label{yesterday}

\texttt{yesterday} --- date (batch 2) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yesterday $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yesterday |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yield\_to\_maturity}}{yield\_to\_maturity}}\label{yield_to_maturity}

\texttt{yield\_to\_maturity} --- batch 57 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yield\_to\_maturity $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yielddisc}}{yielddisc}}\label{yielddisc}

\texttt{yielddisc} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yielddisc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yielddisc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yieldmat}}{yieldmat}}\label{yieldmat}

\texttt{yieldmat} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yieldmat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yieldmat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ylll\_pml}}{ylll\_pml}}\label{ylll_pml}

\texttt{ylll\_pml} --- batch 61 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ylll\_pml $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ylll\_pml |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yn}}{yn}}\label{yn}

\texttt{yn} --- batch 72 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yn $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map yn |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ytm\_newton}}{ytm\_newton}}\label{ytm_newton}

\texttt{ytm\_newton} --- batch 20 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ytm\_newton $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ytm\_newton |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{yuv\_to\_rgb}}{yuv\_to\_rgb}}\label{yuv_to_rgb}

\texttt{yuv\_to\_rgb} --- batch 82 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = yuv\_to\_rgb $input }
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{z\_array}}{z\_array}}\label{z_array}

\texttt{z\_array} --- batch 10 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = z\_array $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map z\_array |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{z\_func}}{z\_func}}\label{z_func}

\texttt{z\_func} --- batch 10 builtin. Alias for \texttt{z\_array}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = z\_func $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map z\_func |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{z\_function\_alt}}{z\_function\_alt}}\label{z_function_alt}

\texttt{z\_function\_alt} --- batches 14-16 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = z\_function\_alt $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map z\_function\_alt |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{z\_score}}{z\_score}}\label{z_score}

\texttt{z\_score(\$value,\ \$mean,\ \$stddev)} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $z = z\_score(85, 75, 10)}
\NormalTok{p $z   \# 1 (one stddev above mean)}
\NormalTok{p z\_score(50, 60, 5)   \# {-}2}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{z\_score\_robust}}{z\_score\_robust}}\label{z_score_robust}

\texttt{z\_score\_robust} --- batch 11 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = z\_score\_robust $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map z\_score\_robust |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{z\_scores}}{z\_scores}}\label{z_scores}

\texttt{z\_scores(@data)} --- 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.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my @grades = (70, 80, 90)}
\NormalTok{my $zs = z\_scores(@grades)}
\NormalTok{p @$zs   \# ({-}1, 0, 1)}
\NormalTok{@data |\textgreater{} z\_scores |\textgreater{} e p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zadd}}{zadd}}\label{zadd}

\texttt{zadd} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zadd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zadd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zalgo}}{zalgo}}\label{zalgo}

\texttt{zalgo} --- string processing (uncategorized batch) builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zalgo $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zalgo |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zall}}{zall}}\label{zall}

\texttt{zall} --- go/general functional utilities builtin. Alias for
\texttt{zip\_all}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zall $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zall |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zcard}}{zcard}}\label{zcard}

\texttt{zcard} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zcard $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zcard |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zcount}}{zcount}}\label{zcount}

\texttt{zcount} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zcross}}{zcross}}\label{zcross}

\texttt{zcross} --- matrix operations (uncategorized batch) builtin.
Alias for \texttt{zero\_crossings}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zcross $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zcross |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeeman\_energy}}{zeeman\_energy}}\label{zeeman_energy}

\texttt{zeeman\_energy} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeeman\_energy $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeeman\_energy |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeller\_day\_of\_week}}{zeller\_day\_of\_week}}\label{zeller_day_of_week}

\texttt{zeller\_day\_of\_week} --- batch 13 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeller\_day\_of\_week $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeller\_day\_of\_week |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeno\_survival}}{zeno\_survival}}\label{zeno_survival}

\texttt{zeno\_survival} --- batch 32 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeno\_survival $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeno\_survival |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zero}}{zero}}\label{zero}

\texttt{zero} --- trivial numeric / predicate builtins builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zero $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zero |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zero\_crossings}}{zero\_crossings}}\label{zero_crossings}

\texttt{zero\_crossings} --- matrix operations (uncategorized batch)
builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zero\_crossings $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zero\_crossings |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zero\_order\_concentration}}{zero\_order\_concentration}}\label{zero_order_concentration}

\texttt{zero\_order\_concentration} --- batch 21 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zero\_order\_concentration $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zero\_order\_concentration |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zero\_pad}}{zero\_pad}}\label{zero_pad}

\texttt{zero\_pad} --- batch 25 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zero\_pad $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zero\_pad |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zero\_sum\_minmax}}{zero\_sum\_minmax}}\label{zero_sum_minmax}

\texttt{zero\_sum\_minmax} --- batch 43 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zero\_sum\_minmax $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zero\_sum\_minmax |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeros}}{zeros}}\label{zeros}

\texttt{zeros} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeros $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeros |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeros\_mat}}{zeros\_mat}}\label{zeros_mat}

\texttt{zeros\_mat} --- matrix / linear algebra builtin. Alias for
\texttt{zeros\_matrix}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeros\_mat $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeros\_mat |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeros\_matrix}}{zeros\_matrix}}\label{zeros_matrix}

\texttt{zeros\_matrix} --- matrix / linear algebra builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeros\_matrix $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeros\_matrix |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zeta\_potential\_estimate}}{zeta\_potential\_estimate}}\label{zeta_potential_estimate}

\texttt{zeta\_potential\_estimate} --- batch 38 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zeta\_potential\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zeta\_potential\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zfill}}{zfill}}\label{zfill}

\texttt{zfill} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zfill $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zfill |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zfill\_num}}{zfill\_num}}\label{zfill_num}

\texttt{zfill\_num} --- extended stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zfill\_num $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zfill\_num |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zgemm}}{zgemm}}\label{zgemm}

\texttt{zgemm} --- batch 66 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zgemm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zgemm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zincrby}}{zincrby}}\label{zincrby}

\texttt{zincrby} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zincrby $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zincrby |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_all}}{zip\_all}}\label{zip_all}

\texttt{zip\_all} --- go/general functional utilities builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_all $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_all |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_apply}}{zip\_apply}}\label{zip_apply}

\texttt{zip\_apply} --- functional combinators builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_apply $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_apply |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_archive}}{zip\_archive}}\label{zip_archive}

\texttt{zip\_archive} --- crypto / encoding builtin. Alias for
\texttt{zip\_create}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_archive $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_archive |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_central\_dir}}{zip\_central\_dir}}\label{zip_central_dir}

\texttt{zip\_central\_dir} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_central\_dir $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_central\_dir |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_eocd}}{zip\_eocd}}\label{zip_eocd}

\texttt{zip\_eocd} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_eocd $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_eocd |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_fill}}{zip\_fill}}\label{zip_fill}

\texttt{zip\_fill} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_fill $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_fill |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_local\_header}}{zip\_local\_header}}\label{zip_local_header}

\texttt{zip\_local\_header} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_local\_header $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_local\_header |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zip\_with}}{zip\_with}}\label{zip_with}

\texttt{zip\_with} --- functional / iterator builtin. Alias for
\texttt{take\_while}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zip\_with $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zip\_with |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zipf}}{zipf}}\label{zipf}

\texttt{zipf} --- python/ruby stdlib builtin. Alias for
\texttt{zip\_fill}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zipf $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zipf |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zipl}}{zipl}}\label{zipl}

\texttt{zipl} --- python/ruby stdlib builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zipl $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zipl |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zipmap}}{zipmap}}\label{zipmap}

\texttt{zipmap} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zipmap $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zipmap |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{ziv\_lempel\_estimate}}{ziv\_lempel\_estimate}}\label{ziv_lempel_estimate}

\texttt{ziv\_lempel\_estimate} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = ziv\_lempel\_estimate $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map ziv\_lempel\_estimate |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zlexcount}}{zlexcount}}\label{zlexcount}

\texttt{zlexcount} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zlexcount $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zlexcount |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zpk2sos\_step}}{zpk2sos\_step}}\label{zpk2sos_step}

\texttt{zpk2sos\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zpk2sos\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zpk2sos\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zpk2tf\_step}}{zpk2tf\_step}}\label{zpk2tf_step}

\texttt{zpk2tf\_step} --- batch 74 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zpk2tf\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zpk2tf\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zrangebyscore}}{zrangebyscore}}\label{zrangebyscore}

\texttt{zrangebyscore} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zrangebyscore $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zrangebyscore |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zrank}}{zrank}}\label{zrank}

\texttt{zrank} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zrank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zrank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zrem}}{zrem}}\label{zrem}

\texttt{zrem} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zrem $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zrem |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zrevrank}}{zrevrank}}\label{zrevrank}

\texttt{zrevrank} --- batch 71 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zrevrank $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zrevrank |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zrlc}}{zrlc}}\label{zrlc}

\texttt{zrlc} --- physics formulas builtin. Alias for
\texttt{impedance\_rlc}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zrlc $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zrlc |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zscore}}{zscore}}\label{zscore}

\texttt{zscore} --- file stat / path builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zscore $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zscore |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zscore\_count}}{zscore\_count}}\label{zscore_count}

\texttt{zscore\_count} --- batch 33 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zscore\_count $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zscore\_count |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zscore\_norm}}{zscore\_norm}}\label{zscore_norm}

\texttt{zscore\_norm} --- batch 27 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zscore\_norm $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zscore\_norm |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zscores}}{zscores}}\label{zscores}

\texttt{zscores} --- statistics (extended) builtin. Alias for
\texttt{z\_scores}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zscores $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zscores |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zst}}{zst}}\label{zst}

\texttt{zst} --- crypto / encoding builtin. Alias for \texttt{zstd}.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zst $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zst |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zstd\_encode\_step}}{zstd\_encode\_step}}\label{zstd_encode_step}

\texttt{zstd\_encode\_step} --- batch 81 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zstd\_encode\_step $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zstd\_encode\_step |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zstd\_frame\_header}}{zstd\_frame\_header}}\label{zstd_frame_header}

\texttt{zstd\_frame\_header} --- batch 62 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zstd\_frame\_header $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zstd\_frame\_header |\textgreater{} p}
\end{Highlighting}
\end{Shaded}

\section{\texorpdfstring{\texttt{zstd\_window\_size\_log}}{zstd\_window\_size\_log}}\label{zstd_window_size_log}

\texttt{zstd\_window\_size\_log} --- batch 40 builtin.

\begin{Shaded}
\begin{Highlighting}[]
\NormalTok{my $result = zstd\_window\_size\_log $x }
\NormalTok{\# or in a pipeline:}
\NormalTok{@list |\textgreater{} map zstd\_window\_size\_log |\textgreater{} p}
\end{Highlighting}
\end{Shaded}


\end{document}
