diff --git a/libfcns.xml b/libfcns.xml
index 425a84c..de22e2e 100644
--- a/libfcns.xml
+++ b/libfcns.xml
@@ -548,7 +548,7 @@
double
- Return ln(x + 1).Avoids round-off or overflow errors in the intermediate steps.
+ Return ln(x^2 + 1).Avoids round-off or overflow errors in the intermediate steps.
The domain of this function is from -1 to infinity (exclusive). Given -1, the result is negative infinity, and below -1, the result is NaN, not an exception (see IEEE 754). Use impute.ensureFinite to produce errors from infinite or NaN values."
@@ -2091,7 +2091,7 @@
int
- Return the indices in haystack
of the begining and end of the first match defined by pattern
.
+ Return the indices in haystack
of the begining and end of the first match defined by pattern
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2108,7 +2108,7 @@
boolean
- Return true if pattern
matches anywhere within haystack
, otherwise return false.
+ Return true if pattern
matches anywhere within haystack
, otherwise return false. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2125,7 +2125,7 @@
int
- Count the number of times pattern
matches in haystack
.
+ Count the number of times pattern
matches in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2142,7 +2142,7 @@
int
- Return the location indices of the last pattern
match in haystack
.
+ Return the location indices of the last pattern
match in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2159,7 +2159,7 @@
int
- Return the location indices of each pattern
sub-match (group-match) in haystack
.
+ Return the location indices of each pattern
sub-match (group-match) in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2176,7 +2176,7 @@
int
- Return the location indices of every pattern
match in haystack
.
+ Return the location indices of every pattern
match in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2193,7 +2193,7 @@
bytes
- Return an array containing each string that pattern
matched in haystack
.
+ Return an array containing each string that pattern
matched in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2210,7 +2210,7 @@
bytesnull
- Return the first occurance of what pattern
matched in haystack
.
+ Return the first occurance of what pattern
matched in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2227,7 +2227,7 @@
bytes
- Return an array of strings or bytes for each pattern
sub-match (group-match) at the first occurance of pattern
in haystack
.
+ Return an array of strings or bytes for each pattern
sub-match (group-match) at the first occurance of pattern
in haystack
. Regular expressions follow the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2244,7 +2244,7 @@
bytes
- Return an array of strings or bytes for each pattern
sub-match (group-match) at every occurance of pattern
in haystack
.
+ Return an array of strings or bytes for each pattern
sub-match (group-match) at every occurance of pattern
in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2261,7 +2261,7 @@
int
- Return the location indices of each pattern
sub-match (group-match) for each occurance of pattern
in haystack
.
+ Return the location indices of each pattern
sub-match (group-match) for each occurance of pattern
in haystack
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2280,7 +2280,7 @@
bytes
- Replace the first pattern
match in haystack
with replacement
.
+ Replace the first pattern
match in haystack
with replacement
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2316,7 +2316,7 @@
bytes
- Break haystack
into an array of strings or bytes on the separator defined by pattern
.
+ Break haystack
into an array of strings or bytes on the separator defined by pattern
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
@@ -2335,7 +2335,7 @@
bytes
- Replace the all pattern
matches in haystack
with replacement
.
+ Replace the all pattern
matches in haystack
with replacement
. The regular expression follows the POSIX extended standard (like grep -e
in Linux and UNIX).
If pattern
is not a valid regular expression, a "bad pattern" error is raised.
diff --git a/make-specification/libfcns.tex b/make-specification/libfcns.tex
index f6904b1..1d2ebc7 100644
--- a/make-specification/libfcns.tex
+++ b/make-specification/libfcns.tex
@@ -140,21 +140,21 @@
{s.replacefirst}{\hypertarget{s.replacefirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc \{"s.replacefirst":$\!$ [s, original, replacement]\} \vspace{0.2 cm} \\} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc s \rm & string \\ & \PFAc original \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the first (leftmost) instance of the substring {\PFAp original} from {\PFAp s} with {\PFAp replacement}. \vspace{0.2 cm} \\ }}%
{s.replacelast}{\hypertarget{s.replacelast}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc \{"s.replacelast":$\!$ [s, original, replacement]\} \vspace{0.2 cm} \\} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc s \rm & string \\ & \PFAc original \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the last (rightmost) instance of the substring {\PFAp original} from {\PFAp s} with {\PFAp replacement}. \vspace{0.2 cm} \\ }}%
{s.translate}{\hypertarget{s.translate}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc \{"s.translate":$\!$ [s, oldchars, newchars]\} \vspace{0.2 cm} \\} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc s \rm & string \\ & \PFAc oldchars \rm & string \\ & \PFAc newchars \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} For each character in {\PFAp s} that is also in {\PFAp oldchars} with some index {\PFAc i}, replace it with the character at index {\PFAc i} in {\PFAp newchars}. Any character in {\PFAp s} that is not in {\PFAp oldchars} is unchanged. Any index {\PFAc i} that is greater than the length of {\PFAp newchars} is replaced with nothing. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Details:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}This is the behavior of the the Posix command {\PFAc tr}, where {\PFAp s} takes the place of standard input and {\PFAp oldchars} and {\PFAp newchars} are the {\PFAc tr} commandline options.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.index}{\hypertarget{re.index}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.index":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the indices in {\PFAp haystack} of the begining and end of the first match defined by {\PFAp pattern}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35000:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.contains}{\hypertarget{re.contains}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.contains":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & boolean \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & boolean \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return true if {\PFAp pattern} matches anywhere within {\PFAp haystack}, otherwise return false. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35010:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.count}{\hypertarget{re.count}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.count":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Count the number of times {\PFAp pattern} matches in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35020:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.rindex}{\hypertarget{re.rindex}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.rindex":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of the last {\PFAp pattern} match in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35030:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.groups}{\hypertarget{re.groups}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.groups":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of each {\PFAp pattern} sub-match (group-match) in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35040:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.indexall}{\hypertarget{re.indexall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.indexall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of every {\PFAp pattern} match in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35050:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.findall}{\hypertarget{re.findall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return an array containing each string that {\PFAp pattern} matched in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35060:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.findfirst}{\hypertarget{re.findfirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findfirst":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & union of \{string, null\} \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & union of \{bytes, null\} \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the first occurance of what {\PFAp pattern} matched in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35070:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.findgroupsfirst}{\hypertarget{re.findgroupsfirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findgroupsfirst":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return an array of strings or bytes for each {\PFAp pattern} sub-match (group-match) at the first occurance of {\PFAp pattern} in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35080:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.findgroupsall}{\hypertarget{re.findgroupsall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findgroupsall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return an array of strings or bytes for each {\PFAp pattern} sub-match (group-match) at every occurance of {\PFAp pattern} in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35090:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.groupsall}{\hypertarget{re.groupsall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.groupsall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of each {\PFAp pattern} sub-match (group-match) for each occurance of {\PFAp pattern} in {\PFAp haystack}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35100:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.replacefirst}{\hypertarget{re.replacefirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.replacefirst":$\!$ [haystack, pattern, replacement]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & \PFAc replacement \rm & bytes \\ & {\it (returns)} & bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the first {\PFAp pattern} match in {\PFAp haystack} with {\PFAp replacement}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35110:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.index}{\hypertarget{re.index}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.index":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the indices in {\PFAp haystack} of the begining and end of the first match defined by {\PFAp pattern}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35000:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.contains}{\hypertarget{re.contains}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.contains":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & boolean \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & boolean \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return true if {\PFAp pattern} matches anywhere within {\PFAp haystack}, otherwise return false. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35010:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.count}{\hypertarget{re.count}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.count":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Count the number of times {\PFAp pattern} matches in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35020:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.rindex}{\hypertarget{re.rindex}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.rindex":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of the last {\PFAp pattern} match in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35030:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.groups}{\hypertarget{re.groups}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.groups":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of each {\PFAp pattern} sub-match (group-match) in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35040:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.indexall}{\hypertarget{re.indexall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.indexall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of every {\PFAp pattern} match in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35050:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.findall}{\hypertarget{re.findall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return an array containing each string that {\PFAp pattern} matched in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35060:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.findfirst}{\hypertarget{re.findfirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findfirst":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & union of \{string, null\} \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & union of \{bytes, null\} \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the first occurance of what {\PFAp pattern} matched in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35070:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.findgroupsfirst}{\hypertarget{re.findgroupsfirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findgroupsfirst":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return an array of strings or bytes for each {\PFAp pattern} sub-match (group-match) at the first occurance of {\PFAp pattern} in {\PFAp haystack}. Regular expressions follow the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35080:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.findgroupsall}{\hypertarget{re.findgroupsall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.findgroupsall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return an array of strings or bytes for each {\PFAp pattern} sub-match (group-match) at every occurance of {\PFAp pattern} in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35090:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.groupsall}{\hypertarget{re.groupsall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.groupsall":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of array of array of int \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of array of array of int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Return the location indices of each {\PFAp pattern} sub-match (group-match) for each occurance of {\PFAp pattern} in {\PFAp haystack}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35100:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.replacefirst}{\hypertarget{re.replacefirst}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.replacefirst":$\!$ [haystack, pattern, replacement]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & \PFAc replacement \rm & bytes \\ & {\it (returns)} & bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the first {\PFAp pattern} match in {\PFAp haystack} with {\PFAp replacement}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35110:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
{re.replacelast}{\hypertarget{re.replacelast}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.replacelast":$\!$ [haystack, pattern, replacement]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & \PFAc replacement \rm & bytes \\ & {\it (returns)} & bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the last {\PFAp pattern} match in {\PFAp haystack} with {\PFAp replacement}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35120:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.split}{\hypertarget{re.split}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.split":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Break {\PFAp haystack} into an array of strings or bytes on the separator defined by {\PFAp pattern}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35130:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
- {re.replaceall}{\hypertarget{re.replaceall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.replaceall":$\!$ [haystack, pattern, replacement]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & \PFAc replacement \rm & bytes \\ & {\it (returns)} & bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the all {\PFAp pattern} matches in {\PFAp haystack} with {\PFAp replacement}. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35140:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.split}{\hypertarget{re.split}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.split":$\!$ [haystack, pattern]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & {\it (returns)} & array of string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & {\it (returns)} & array of bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Break {\PFAp haystack} into an array of strings or bytes on the separator defined by {\PFAp pattern}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35130:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
+ {re.replaceall}{\hypertarget{re.replaceall}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc\{"re.replaceall":$\!$ [haystack, pattern, replacement]\}} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & string \\ & \PFAc pattern \rm & string \\ & \PFAc replacement \rm & string \\ & {\it (returns)} & string \\ \end{tabular} \vspace{0.2 cm} \\ \mbox{\hspace{1.5 cm}}or \vspace{0.2 cm} \\ \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc haystack \rm & bytes \\ & \PFAc pattern \rm & bytes \\ & \PFAc replacement \rm & bytes \\ & {\it (returns)} & bytes \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Replace the all {\PFAp pattern} matches in {\PFAp haystack} with {\PFAp replacement}. The regular expression follows the POSIX extended standard (like {\PFAp grep -e} in Linux and UNIX). \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#35140:} If {\PFAp pattern} is not a valid regular expression, a ``bad pattern'' error is raised.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
{parse.int}{\hypertarget{parse.int}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc \{"parse.int":$\!$ [str, base]\} \vspace{0.2 cm} \\} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc str \rm & string \\ & \PFAc base \rm & int \\ & {\it (returns)} & int \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Parse {\PFAp str} and return its value as an integer with base {\PFAp base}, if possible. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Details:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}The string is interpreted as though leading and trailing whitespace were removed and is case-insensitive. \vspace{0.1 cm} \\ Leading or trailing whitespace and any capitalization is allowed.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#33000:} Raises ``not an integer'' if the string does not conform to ``{\PFAc [-+]?[0-9a-z]+}'' or the number it evaluates to is too large to represent as a 32-bit integer or uses characters as large as or larger than {\PFAp base} ('0' through '9' encode 0 through 9 and 'a' through 'z' encode 10 through 35). \vspace{0.1 cm} \\ {\bf \#33001:} Raises ``base out of range'' if {\PFAp base} is less than 2 or greater than 36.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
{parse.long}{\hypertarget{parse.long}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc \{"parse.long":$\!$ [str, base]\} \vspace{0.2 cm} \\} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc str \rm & string \\ & \PFAc base \rm & int \\ & {\it (returns)} & long \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Parse {\PFAp str} and return its value as a long integer with base {\PFAp base}, if possible. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Details:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}The string is interpreted as though leading and trailing whitespace were removed and is case-insensitive. \vspace{0.1 cm} \\ Leading or trailing whitespace and any capitalization is allowed.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#33010:} Raises ``not a long integer'' if the string does not conform to ``{\PFAc [-+]?[0-9a-z]+}'' or the number it evaluates to is too large to represent as a 64-bit integer or uses characters as large as or larger than {\PFAp base} ('0' through '9' encode 0 through 9 and 'a' through 'z' encode 10 through 35). \vspace{0.1 cm} \\ {\bf \#33011:} Raises ``base out of range'' if {\PFAp base} is less than 2 or greater than 36.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%
{parse.float}{\hypertarget{parse.float}{\noindent \mbox{\hspace{0.015\linewidth}} {\bf Signature:} \mbox{\PFAc \{"parse.float":$\!$ [str]\} \vspace{0.2 cm} \\} \vspace{0.2 cm} \\ \rm \begin{tabular}{p{0.01\linewidth} l p{0.8\linewidth}} & \PFAc str \rm & string \\ & {\it (returns)} & float \\ \end{tabular} \vspace{0.3 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Description:} Parse {\PFAp str} and return its value as a single-precision floating point number. \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Details:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}The string is interpreted as though leading and trailing whitespace were removed and is case-insensitive. \vspace{0.1 cm} \\ If the string is ``nan'', the resulting value is not-a-number and if the string is ``inf'', ``+inf'', or ``-inf'', the resulting value is positive infinity, positive infinity, or negative infinity, respectively (see IEEE 754). \vspace{0.1 cm} \\ If the number's magnitude is too large to be represented as a single-precision float, the resulting value is positive or negative infinity (depending on the sign). If the numbers magnitude is too small to be represented as a single-precision float, the resulting value is zero. \vspace{0.1 cm} \\ Leading or trailing whitespace and any capitalization is allowed.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ \mbox{\hspace{0.015\linewidth}} {\bf Runtime Errors:} \vspace{0.2 cm} \\ \mbox{\hspace{0.045\linewidth}} \begin{minipage}{0.935\linewidth}{\bf \#33020:} Raises ``not a single-precision float'' if the string does not conform to ``{\PFAc [-+]?(\\.?[0-9]+|[0-9]+\\.[0-9]*)([eE][-+]?[0-9]+)?}'', ``inf'', ``+inf'', ``-inf'', or ``nan''.\end{minipage} \vspace{0.2 cm} \vspace{0.2 cm} \\ }}%