This is the april Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Mon Feb 26 14:35:33 2024 GMT+0.
april/april.asdvex/vex.asdmaxpc-apache/maxpc-apache.asdaplesque/aplesque.asdvarray/varray.asdapril/package.lispapril/utilities.lispapril/functions.lispapril/grammar.lispapril/spec.lispapril/novelties.lispvex/package.lispvex/vex.lispmaxpc-apache/packages.lispmaxpc-apache/input.lispmaxpc-apache/input/index.lispmaxpc-apache/input/list.lispmaxpc-apache/input/vector.lispmaxpc-apache/input/stream.lispmaxpc-apache/interface.lispmaxpc-apache/primitives.lispmaxpc-apache/more.lispmaxpc-apache/char.lispmaxpc-apache/digit.lispaplesque/package.lispaplesque/forms.lispaplesque/aplesque.lispvarray/package.lispvarray/macros.lispvarray/base.lispvarray/index.lispvarray/primal.lispvarray/derived.lispvarray/calculate.lispvarray/select.lispvarray/logic.lispvarray/composed.lispvarray/effectors/x86.lispThe main system appears first, followed by any subsystem dependency.
aprilApril is a subset of the APL programming language that compiles to Common Lisp.
Andrew Sengul
Apache-2.0
1.0.0
package.lisp (file).
utilities.lisp (file).
functions.lisp (file).
grammar.lisp (file).
spec.lisp (file).
novelties.lisp (file).
vexA set of templates for implementing a vector programming language that compiles to Common Lisp.
Andrew Sengul
Apache-2.0
1.0.0
alexandria (system).
array-operations (system).
maxpc-apache (system).
cl-ppcre (system).
symbol-munger (system).
prove (system).
package.lisp (file).
vex.lisp (file).
maxpc-apacheMax’s Parser Combinators: a simple and pragmatic library for writing parsers and lexers based on combinatory parsing.
Max Rottenkolber <max@mr.gy>
Apache-2.0
packages.lisp (file).
input.lisp (file).
input/index.lisp (file).
input/list.lisp (file).
input/vector.lisp (file).
input/stream.lisp (file).
interface.lisp (file).
primitives.lisp (file).
more.lisp (file).
char.lisp (file).
digit.lisp (file).
aplesqueA collection of array manipulation functions patterned after functions from the APL language.
Andrew Sengul
Apache-2.0
1.0.0
cl-ppcre (system).
alexandria (system).
array-operations (system).
parse-number (system).
symbol-munger (system).
lparallel (system).
package.lisp (file).
forms.lisp (file).
aplesque.lisp (file).
varrayVarray implements virtual arrays - objects representing deferred array transformations.
Andrew Sengul
Apache-2.0
1.0.0
aplesque (system).
serapeum (system)., for feature (:not :clasp)
lparallel (system).
random-state (system).
package.lisp (file).
macros.lisp (file).
base.lisp (file).
index.lisp (file).
primal.lisp (file).
derived.lisp (file).
calculate.lisp (file).
select.lisp (file).
logic.lisp (file).
composed.lisp (file).
effectors/x86.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
april/april.asdvex/vex.asdmaxpc-apache/maxpc-apache.asdaplesque/aplesque.asdvarray/varray.asdapril/package.lispapril/utilities.lispapril/functions.lispapril/grammar.lispapril/spec.lispapril/novelties.lispvex/package.lispvex/vex.lispmaxpc-apache/packages.lispmaxpc-apache/input.lispmaxpc-apache/input/index.lispmaxpc-apache/input/list.lispmaxpc-apache/input/vector.lispmaxpc-apache/input/stream.lispmaxpc-apache/interface.lispmaxpc-apache/primitives.lispmaxpc-apache/more.lispmaxpc-apache/char.lispmaxpc-apache/digit.lispaplesque/package.lispaplesque/forms.lispaplesque/aplesque.lispvarray/package.lispvarray/macros.lispvarray/base.lispvarray/index.lispvarray/primal.lispvarray/derived.lispvarray/calculate.lispvarray/select.lispvarray/logic.lispvarray/composed.lispvarray/effectors/x86.lispapril/utilities.lisppackage.lisp (file).
april (system).
ws-assign-fun (macro).
ws-assign-val (macro).
*alphabet-vector* (special variable).
*apl-timestamp* (symbol macro).
*april-idiom* (special variable).
*branches* (symbol macro).
*demo-packages* (special variable).
*digit-vector* (special variable).
*first-axis* (symbol macro).
*first-axis-or-nil* (symbol macro).
*function-identities* (special variable).
*idiom-native-symbols* (special variable).
*io-currying-function-symbols-dyadic* (special variable).
*io-currying-function-symbols-monadic* (special variable).
*last-axis* (symbol macro).
*lib-tests-failed* (special variable).
*lib-tests-run* (special variable).
*library-packages* (special variable).
*package-name-string* (special variable).
*rng-names* (special variable).
*system-variables* (special variable).
*value-composable-lexical-operators* (special variable).
a-call (macro).
a-comp (macro).
a-out (macro).
a-set (macro).
ac-wrap (macro).
achoose (macro).
add-aprepl-load-to-emacs-init-file (function).
adjust-axes-for-index-origin (function).
alambda (macro).
amb-ref (macro).
apl-fn (macro).
apl-fn-s (macro).
apl-if (macro).
apl-timestamp (function).
aprgn (macro).
array-setting-meta (function).
array-to-nested-vector (function).
at-path (function).
avec (function).
build-call-form (function).
build-compiled-code (function).
build-populator (function).
build-variable-declarations (function).
change-namespace (function).
check-value (function).
coerce-or-get-type (function).
count-cpus (function).
disclose-atom (function).
dummy-nargument-function (function).
dummy-operator (function).
enclose-axes (function).
external-workspace-function (function).
external-workspace-operator (function).
external-workspace-value (function).
extract-axes (function).
f-lex (macro).
fn-meta (macro).
follow-path (function).
format-nspath (function).
format-value (function).
function-variant (macro).
get-array-meta (function).
get-assigned-symbols (function).
in-april-workspace (macro).
indent-code (function).
insym (macro).
inv-fn (macro).
invert-function (function).
is-alphanumeric (function).
is-workspace-function (macro).
is-workspace-operator (macro).
is-workspace-value (macro).
lexer-postprocess (function).
load-libs (function).
make-namespace (function).
make-prototype-of (function).
make-virtual (macro).
nspath (macro).
of-meta-hierarchy (function).
olambda (macro).
output-function (function).
output-value (function).
parse-apl-number-string (function).
plain-ref (macro).
print-and-run (macro).
print-apl-number-string (function).
process-fnspecs (function).
process-ns-output (function).
process-output-vector (function).
process-path (function).
reg-side-effect (function).
reg-symfn-call (function).
resolve-function (function).
run-lib-tests (macro).
scalar-code-char (function).
scalar-function (macro).
set-array-meta (function).
side-effect-free (function).
specify-demo (macro).
sub-aliasing (macro).
sub-lex (macro).
system-command-exists (function).
this-idiom (symbol macro).
value-meta-process (macro).
λχ (macro).
λω (macro).
λωα (macro).
λωαχ (macro).
λωχ (macro).
∇ (special variable).
∇∇ (special variable).
april/functions.lisputilities.lisp (file).
april (system).
apl-ceiling (function).
apl-divide (function).
apl-exp (function).
apl-expt (function).
apl-floor (function).
apl-gcd (function).
apl-lcm (function).
apl-log (function).
apl-random (function).
apl-random-process (function).
apl-residue (function).
apl-xcy (function).
assign-by-selection (function).
at-index (function).
binary-not (function).
cmucl-complex-acos (function).
compare-by (function).
complex-floor (function).
count-to (function).
format-array (function).
format-array-uncollated (function).
generate-index-array (function).
invert-assigned-varray (function).
operate-at (function).
operate-at-rank (function).
operate-atop (function).
operate-before (function).
operate-beside (function).
operate-commuting (function).
operate-each (function).
operate-grouping (function).
operate-producing-outer (function).
operate-stenciling (function).
operate-to-power (function).
sb-rationalize (function).
scalar-compare (function).
without (function).
april/grammar.lispfunctions.lisp (file).
april (system).
build-axes (function).
build-function (function).
build-operator (function).
build-value (function).
compile-form (function).
complete-branch-composition (function).
complete-pivotal-match (function).
complete-value-assignment (function).
compose-function-assignment (function).
compose-function-lateral (function).
compose-function-pivotal (function).
compose-function-train (function).
compose-value-assignment (function).
fnexp-backup (function).
process-function (function).
process-operator (function).
process-value (function).
resolve-path (function).
set-namespace-point (function).
april/spec.lispgrammar.lisp (file).
april (system).
april (macro).
april-c (macro).
april-clear-workspace (macro).
april-create-workspace (macro).
april-f (macro).
april-load (macro).
with-april-context (macro).
april-lex-fn-! (function).
april-lex-fn-* (function).
april-lex-fn-+ (function).
april-lex-fn-, (function).
april-lex-fn-- (function).
april-lex-fn-/ (function).
april-lex-fn-< (function).
april-lex-fn-= (function).
april-lex-fn-> (function).
april-lex-fn-? (function).
april-lex-fn-\ (function).
april-lex-fn-^ (function).
april-lex-fn-| (function).
april-lex-fn-~ (function).
april-lex-fn-× (function).
april-lex-fn-÷ (function).
april-lex-fn-↑ (function).
april-lex-fn-↓ (function).
april-lex-fn-∊ (function).
april-lex-fn-∧ (function).
april-lex-fn-∨ (function).
april-lex-fn-∩ (function).
april-lex-fn-∪ (function).
april-lex-fn-≠ (function).
april-lex-fn-≡ (function).
april-lex-fn-≢ (function).
april-lex-fn-≤ (function).
april-lex-fn-≥ (function).
april-lex-fn-⊂ (function).
april-lex-fn-⊃ (function).
april-lex-fn-⊆ (function).
april-lex-fn-⊖ (function).
april-lex-fn-⊢ (function).
april-lex-fn-⊣ (function).
april-lex-fn-⊤ (function).
april-lex-fn-⊥ (function).
april-lex-fn-⋆ (function).
april-lex-fn-⌈ (function).
april-lex-fn-⌊ (function).
april-lex-fn-⌷ (function).
april-lex-fn-⌹ (function).
april-lex-fn-⌽ (function).
april-lex-fn-⌿ (function).
april-lex-fn-⍀ (function).
april-lex-fn-⍉ (function).
april-lex-fn-⍋ (function).
april-lex-fn-⍎ (function).
april-lex-fn-⍒ (function).
april-lex-fn-⍕ (function).
april-lex-fn-⍟ (function).
april-lex-fn-⍪ (function).
april-lex-fn-⍱ (function).
april-lex-fn-⍲ (function).
april-lex-fn-⍳ (function).
april-lex-fn-⍴ (function).
april-lex-fn-⍷ (function).
april-lex-fn-⍸ (function).
april-lex-fn-○ (function).
april-lex-op-. (function).
april-lex-op-/ (function).
april-lex-op-@ (function).
april-lex-op-\ (function).
april-lex-op-¨ (function).
april-lex-op-∘ (function).
april-lex-op-⌸ (function).
april-lex-op-⌺ (function).
april-lex-op-⌿ (function).
april-lex-op-⍀ (function).
april-lex-op-⍛ (function).
april-lex-op-⍣ (function).
april-lex-op-⍤ (function).
april-lex-op-⍥ (function).
april-lex-op-⍨ (function).
april-lex-st-$ (function).
april-lex-st-⍢ (function).
april-ref (function).
call-circular (function).
april/novelties.lispspec.lisp (file).
april (system).
april-print-progress-bar (function).
display-banner (function).
life (function).
vex/vex.lisppackage.lisp (file).
vex (system).
boolean-op (macro).
extend-vex-idiom (macro).
get-system-meta (generic function).
idiom-symbols (reader method).
(setf idiom-symbols) (writer method).
of-lexicons (generic function).
of-system (generic function).
of-utilities (generic function).
reverse-op (macro).
set-system-meta (generic function).
specify-vex-idiom (macro).
vex-program (function).
=vex-string (function).
build-profile (function).
count-symbol-in-spec (function).
derive-opglyphs (function).
idiom (class).
idiom-lexicons (reader method).
(setf idiom-lexicons) (writer method).
idiom-name (reader method).
(setf idiom-name) (writer method).
idiom-system (reader method).
(setf idiom-system) (writer method).
idiom-utilities (reader method).
(setf idiom-utilities) (writer method).
merge-options (function).
process-arbitrary-tests-for (function).
process-general-tests-for (function).
process-lex-tests-for (function).
vex-idiom-spec (macro).
with-open-vex-file (macro).
maxpc-apache/input.lisppackages.lisp (file).
maxpc-apache (system).
input-element-type (generic function).
input-empty-p (generic function).
input-first (generic function).
input-position (generic function).
input-rest (generic function).
input-sequence (generic function).
make-input (generic function).
maxpc-apache/input/index.lisppackages.lisp (file).
input.lisp (file).
maxpc-apache (system).
index (structure).
index-position (reader).
index-position (type).
input-position (method).
copy-index (function).
index-p (function).
make-index (function).
maxpc-apache/input/list.lisppackages.lisp (file).
input.lisp (file).
input/index.lisp (file).
maxpc-apache (system).
input-empty-p (method).
input-first (method).
input-rest (method).
input-sequence (method).
make-input (method).
copy-index-list (function).
index-list (structure).
index-list-list (reader).
index-list-p (function).
index-list-position (function).
make-index-list (function).
maxpc-apache/input/vector.lisppackages.lisp (file).
input.lisp (file).
input/index.lisp (file).
maxpc-apache (system).
input-element-type (method).
input-empty-p (method).
input-first (method).
input-first (method).
input-first (method).
input-rest (method).
input-rest (method).
input-rest (method).
input-sequence (method).
make-input (method).
copy-index-simple-string (function).
copy-index-simple-vector (function).
copy-index-vector (function).
index-simple-string (structure).
index-simple-string-p (function).
index-simple-string-position (function).
index-simple-string-vector (function).
index-simple-vector (structure).
index-simple-vector-p (function).
index-simple-vector-position (function).
index-simple-vector-vector (function).
index-vector (structure).
index-vector-p (function).
index-vector-position (function).
index-vector-vector (reader).
make-index-simple-string (function).
make-index-simple-vector (function).
make-index-vector (function).
maxpc-apache/input/stream.lisppackages.lisp (file).
input.lisp (file).
input/index.lisp (file).
maxpc-apache (system).
*bound* (special variable).
*chunk-size* (special variable).
*element-type* (special variable).
input-element-type (method).
input-empty-p (method).
input-first (method).
input-rest (method).
input-sequence (method).
make-input (method).
copy-index-stream (function).
element-type (function).
fill-buffer (generic function).
index-stream (structure).
index-stream-buffer (reader).
index-stream-p (function).
index-stream-position (function).
index-stream-stream (reader).
make-index-stream (function).
maybe-fill-buffer (function).
maxpc-apache/interface.lisppackages.lisp (file).
input.lisp (file).
maxpc-apache (system).
%handler-case (macro).
%restart-case (macro).
get-input-position (function).
parse (function).
*input-fail* (special variable).
*input-start* (special variable).
cases-to-parser-cases (function).
parse-line-position (function).
maxpc-apache/primitives.lisppackages.lisp (file).
input.lisp (file).
maxpc-apache (system).
maxpc-apache/more.lisppackages.lisp (file).
primitives.lisp (file).
maxpc-apache (system).
maxpc-apache/char.lisppackages.lisp (file).
primitives.lisp (file).
more.lisp (file).
maxpc-apache (system).
*whitespace* (special variable).
=line (function).
?char (function).
?newline (function).
?string (function).
?whitespace (function).
maxpc-apache/digit.lisppackages.lisp (file).
primitives.lisp (file).
more.lisp (file).
maxpc-apache (system).
=integer-number (function).
=natural-number (function).
?digit (function).
aplesque/forms.lisppackage.lisp (file).
aplesque (system).
indexer-enclose (function).
indexer-expand (function).
indexer-permute (function).
indexer-section (function).
indexer-split (function).
indexer-turn (function).
aplesque/aplesque.lispforms.lisp (file).
aplesque (system).
across (function).
alpha-compare (function).
apl-array-prototype (function).
apply-scalar (function).
array-compare (function).
array-depth (function).
array-grade (function).
array-impress (function).
array-inner-product (function).
array-outer-product (function).
array-promote (function).
array-to-list (function).
assign-element-type (function).
binomial (function).
catenate (function).
choose (function).
copy-nested-array (function).
count-segments (function).
disclose (function).
disclose-unitary (function).
duplicate (function).
enclose (function).
enclose-atom (function).
enlist (function).
expand (function).
find-array (function).
get-dimensional-factors (function).
get-first-or-disclose (function).
grade (function).
index-of (function).
interval-index (function).
inverse-outer-product (function).
invert-matrix (function).
is-integer-array (function).
is-unitary (function).
laminate (function).
left-invert-matrix (function).
make-empty-array (function).
matrix-print (macro).
mix-arrays (function).
nest (function).
partition-array (function).
partitioned-enclose (function).
permute-axes (function).
ravel (function).
re-enclose (function).
reduce-array (function).
reshape-to-fit (function).
scale-array (function).
section (function).
split-array (function).
sprfact (function).
stencil (function).
turn (function).
type-in-common (function).
varef (function).
(setf varef) (function).
xdotimes (macro).
ydotimes (macro).
*sub-7-bit-element-processing-register-size* (special variable).
axes-to-indices (function).
gamma (function).
get-free-threads (function).
ibinomial (function).
isprfact (function).
near-integerp (function).
near-realp (function).
rmi-convert (function).
rmi-from-subscript-vector (function).
sub-7-bit-integer-elements-p (function).
vector-grade (function).
varray/macros.lisppackage.lisp (file).
varray (system).
intraverser (macro).
varray/base.lispmacros.lisp (file).
varray (system).
allocate-instance (method).
assign-rank (generic function).
etype-of (generic function).
generator-of (generic function).
initialize-instance (method).
rank-of (generic function).
shape-of (generic function).
size-of (generic function).
validate-superclass (method).
varray (class).
varrayp (function).
vrender (function).
*april-parallel-kernel* (special variable).
*package-name-string* (special variable).
*workers-count* (special variable).
apl-array-prototype (function).
ava-dimension (type).
ava-rank (type).
ava-size (type).
ava-worker-count (type).
build-decoder (function).
build-encoder (function).
build-iterator (function).
decode-rmi (function).
effect (generic function).
effector-of (generic function).
encode-rmi (function).
get-dimensional-factors (function).
get-indexing-function (function).
get-or-assign-shape (macro).
get-promised (macro).
get-reduced (generic function).
incrementer-encoded (function).
indexer-of (generic function).
join-indexers (function).
make-threading-kernel-if-absent (function).
metadata-of (generic function).
nested-base (function).
nested-p (function).
prototype-of (generic function).
render (generic function).
segment-length (function).
specify (generic function).
sub-byte-element-type (function).
sub-indexer-of (generic function).
va-class (class).
vad-nested (class).
vad-with-dfactors (class).
vad-with-io (class).
vader-base (reader method).
(setf vader-base) (writer method).
vader-content (reader method).
(setf vader-content) (writer method).
vader-layer (reader method).
(setf vader-layer) (writer method).
vads-dfactors (reader method).
(setf vads-dfactors) (writer method).
vads-io (reader method).
(setf vads-io) (writer method).
vads-nested (reader method).
vads-nested (reader method).
(setf vads-nested) (writer method).
(setf vads-nested) (writer method).
varray-derived (class).
varray-generator (reader method).
(setf varray-generator) (writer method).
varray-meta (reader method).
(setf varray-meta) (writer method).
varray-primal (class).
varray-prototype (reader method).
(setf varray-prototype) (writer method).
varray-shape (reader method).
(setf varray-shape) (writer method).
varray/index.lispbase.lisp (file).
varray (system).
indexer-permute (function).
indexer-section (function).
indexer-turn (function).
varray/primal.lispindex.lisp (file).
varray (system).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
vapri-apro-vector (class).
vapri-coordinate-identity (class).
vapri-onehot-vector (class).
fast-iota-sum (function).
fast-iota-sum-fixnum (type).
get-reduced (method).
iota-sum (function).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
vacov-index (reader method).
(setf vacov-index) (writer method).
vacov-reference (reader method).
(setf vacov-reference) (writer method).
vaohv-index (reader method).
(setf vaohv-index) (writer method).
vapci-shape (reader method).
(setf vapci-shape) (writer method).
vapip-factor (reader method).
(setf vapip-factor) (writer method).
vapip-number (reader method).
(setf vapip-number) (writer method).
vapip-offset (reader method).
(setf vapip-offset) (writer method).
vapip-origin (reader method).
(setf vapip-origin) (writer method).
vapip-repeat (reader method).
(setf vapip-repeat) (writer method).
vapri-axis-vector (class).
vapri-coordinate-vector (class).
vaxv-axis (reader method).
(setf vaxv-axis) (writer method).
vaxv-index (reader method).
(setf vaxv-index) (writer method).
vaxv-reference (reader method).
(setf vaxv-reference) (writer method).
vaxv-window (reader method).
(setf vaxv-window) (writer method).
varray/derived.lispprimal.lisp (file).
varray (system).
assign-rank (method).
assign-rank (method).
assign-rank (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
etype-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
initialize-instance (method).
initialize-instance (method).
inverse-count-to (generic function).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
vader-catenate (class).
vader-compare (class).
vader-deal (class).
vader-decode (class).
vader-depth (class).
vader-enclose (class).
vader-encode (class).
vader-enlist (class).
vader-expand (class).
vader-find (class).
vader-first-dim (class).
vader-grade (class).
vader-identity (class).
vader-index (class).
vader-intersection (class).
vader-interval-index (class).
vader-inverse-where (class).
vader-matrix-divide (class).
vader-matrix-inverse (class).
vader-membership (class).
vader-mix (class).
vader-pare (class).
vader-partition (class).
vader-permute (class).
vader-pick (class).
vader-random (class).
vader-reshape (class).
vader-section (class).
vader-shape (class).
vader-split (class).
vader-subarray (class).
vader-turn (class).
vader-umask (class).
vader-union (class).
vader-unique (class).
vader-where (class).
vader-without (class).
varray-compare (function).
apl-random-process (function).
arg-process (function).
assign-reference (generic function).
effector-of (method).
effector-of (method).
effector-of (method).
effector-of (method).
fetch-reference (generic function).
get-path-value (function).
indexer-of (method).
indexer-of (method).
indexer-of (method).
linear-regression (function).
matrix-divide (function).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
render (method).
vacat-laminating (reader method).
(setf vacat-laminating) (writer method).
vad-invertable (class).
vad-limitable (class).
vad-maybe-shapeless (class).
vad-on-axis (class).
vad-reindexing (class).
vad-render-mutable (class).
vad-with-argument (class).
vad-with-ct (class).
vad-with-default-axis (class).
vad-with-rng (class).
vadeal-cached (reader method).
(setf vadeal-cached) (writer method).
vader-subarray-split (class).
vadex-separating (reader method).
(setf vadex-separating) (writer method).
vads-argument (reader method).
(setf vads-argument) (writer method).
vads-axis (reader method).
(setf vads-axis) (writer method).
vads-ct (reader method).
(setf vads-ct) (writer method).
vads-default-axis (reader method).
(setf vads-default-axis) (writer method).
vads-inverse (reader method).
(setf vads-inverse) (writer method).
vads-rendered (reader method).
(setf vads-rendered) (writer method).
vads-rng (reader method).
(setf vads-rng) (writer method).
vads-shapeset (reader method).
(setf vads-shapeset) (writer method).
vaenc-inner-shape (reader method).
(setf vaenc-inner-shape) (writer method).
vafind-cached (reader method).
(setf vafind-cached) (writer method).
vafind-pattern (reader method).
(setf vafind-pattern) (writer method).
vaix-cache (reader method).
(setf vaix-cache) (writer method).
vaix-set (reader method).
(setf vaix-set) (writer method).
vamem-to-search (reader method).
(setf vamem-to-search) (writer method).
vamix-cached-elements (reader method).
(setf vamix-cached-elements) (writer method).
vamix-shape-indices (reader method).
(setf vamix-shape-indices) (writer method).
vapart-params (reader method).
(setf vapart-params) (writer method).
vaperm-is-diagonal (reader method).
(setf vaperm-is-diagonal) (writer method).
vapick-apath-index (reader method).
(setf vapick-apath-index) (writer method).
vapick-assign (reader method).
(setf vapick-assign) (writer method).
vapick-function (reader method).
(setf vapick-function) (writer method).
vapick-reference (reader method).
(setf vapick-reference) (writer method).
vapick-selector (reader method).
(setf vapick-selector) (writer method).
varray-depth (function).
vasbs-core-indexer (reader method).
(setf vasbs-core-indexer) (writer method).
vasec-pad (reader method).
(setf vasec-pad) (writer method).
vasec-span (reader method).
(setf vasec-span) (writer method).
vasv-index (reader method).
(setf vasv-index) (writer method).
vaturn-degrees (reader method).
(setf vaturn-degrees) (writer method).
vauni-indices (reader method).
(setf vauni-indices) (writer method).
varray/calculate.lispderived.lisp (file).
varray (system).
etype-of (method).
generator-of (method).
shape-of (method).
vader-calculate (class).
prototype-of (method).
vaop-function (reader method).
(setf vaop-function) (writer method).
vaop-params (reader method).
(setf vaop-params) (writer method).
vaop-sub-shape (reader method).
(setf vaop-sub-shape) (writer method).
varray/select.lispcalculate.lisp (file).
varray (system).
etype-of (method).
generator-of (method).
shape-of (method).
vader-select (class).
vasel-assign (reader method).
(setf vasel-assign) (writer method).
vasel-assign-if (reader method).
(setf vasel-assign-if) (writer method).
vasel-assign-shape (reader method).
(setf vasel-assign-shape) (writer method).
vasel-calling (reader method).
(setf vasel-calling) (writer method).
vasel-selector (reader method).
(setf vasel-selector) (writer method).
varray/logic.lispselect.lisp (file).
varray (system).
extend-allocator-vader-calculate (function).
extend-allocator-vader-expand (function).
extend-allocator-vader-inverse-where (function).
extend-allocator-vader-permute (function).
extend-allocator-vader-section (function).
varray/composed.lisplogic.lisp (file).
varray (system).
etype-of (method).
etype-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
generator-of (method).
op-compose (function).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
shape-of (method).
vacomp-each (class).
vacomp-produce (class).
vacomp-reduce (class).
vacomp-scan (class).
vacomp-stencil (class).
vader-composing (class).
vader-subarray-displaced (class).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
prototype-of (method).
side-effect-free (function).
vacmp-alpha (reader method).
(setf vacmp-alpha) (writer method).
vacmp-async (reader method).
(setf vacmp-async) (writer method).
vacmp-left (reader method).
(setf vacmp-left) (writer method).
vacmp-omega (reader method).
(setf vacmp-omega) (writer method).
vacmp-right (reader method).
(setf vacmp-right) (writer method).
vacred-unitary (reader method).
(setf vacred-unitary) (writer method).
vacst-base-dims (reader method).
(setf vacst-base-dims) (writer method).
vacst-in-factors (reader method).
(setf vacst-in-factors) (writer method).
vacst-movement (reader method).
(setf vacst-movement) (writer method).
vacst-out-factors (reader method).
(setf vacst-out-factors) (writer method).
vacst-win-dims (reader method).
(setf vacst-win-dims) (writer method).
vacst-win-factors (reader method).
(setf vacst-win-factors) (writer method).
vacst-win-offsets (reader method).
(setf vacst-win-offsets) (writer method).
vader-stencil-margin (class).
vader-stencil-window (class).
vader-subarray-reduce (class).
vasbr-delta (reader method).
(setf vasbr-delta) (writer method).
vasbr-reverse (reader method).
(setf vasbr-reverse) (writer method).
vasbr-window (reader method).
(setf vasbr-window) (writer method).
vaste-index (reader method).
(setf vaste-index) (writer method).
vastw-index (reader method).
(setf vastw-index) (writer method).
varray/effectors/x86.lisp(:and :sbcl :x86-64)
composed.lisp (file).
varray (system).
build-decoder-x86asm (function).
build-encoder-x86asm (function).
build-iterator-x86asm (function).
effect (method).
effector-of (method).
effector-of (method).
effector-of (method).
effector-of (method).
mask-signed (function).
Packages are listed by definition order.
maxpc.charmaxpc.input.indexvexapril.demo-definition-toolsvarraymaxpc.input.streammaxpc.inputmaxpc.digitaprilmaxpc.input.vectoraplesque.formsapril.idiom-extension-toolsmaxpc.input.listmaxpcaplesquemaxpc.charUtility parsers for character inputs.
common-lisp.
maxpc.
*whitespace* (special variable).
=line (function).
?char (function).
?newline (function).
?string (function).
?whitespace (function).
maxpc.input.indexcommon-lisp.
maxpc.input.
index (structure).
index-position (reader).
index-position (type).
copy-index (function).
index-p (function).
make-index (function).
vexcommon-lisp.
boolean-op (macro).
extend-vex-idiom (macro).
get-system-meta (generic function).
idiom-symbols (generic reader).
(setf idiom-symbols) (generic writer).
of-lexicons (generic function).
of-system (generic function).
of-utilities (generic function).
reverse-op (macro).
set-system-meta (generic function).
specify-vex-idiom (macro).
vex-program (function).
ws-assign-fun (macro).
ws-assign-val (macro).
=vex-string (function).
build-profile (function).
count-symbol-in-spec (function).
derive-opglyphs (function).
idiom (class).
idiom-lexicons (generic reader).
(setf idiom-lexicons) (generic writer).
idiom-name (generic reader).
(setf idiom-name) (generic writer).
idiom-system (generic reader).
(setf idiom-system) (generic writer).
idiom-utilities (generic reader).
(setf idiom-utilities) (generic writer).
merge-options (function).
process-arbitrary-tests-for (function).
process-general-tests-for (function).
process-lex-tests-for (function).
vex-idiom-spec (macro).
with-open-vex-file (macro).
varraycommon-lisp.
assign-rank (generic function).
etype-of (generic function).
generator-of (generic function).
inverse-count-to (generic function).
op-compose (function).
rank-of (generic function).
shape-of (generic function).
size-of (generic function).
vacomp-each (class).
vacomp-produce (class).
vacomp-reduce (class).
vacomp-scan (class).
vacomp-stencil (class).
vader-calculate (class).
vader-catenate (class).
vader-compare (class).
vader-composing (class).
vader-deal (class).
vader-decode (class).
vader-depth (class).
vader-enclose (class).
vader-encode (class).
vader-enlist (class).
vader-expand (class).
vader-find (class).
vader-first-dim (class).
vader-grade (class).
vader-identity (class).
vader-index (class).
vader-intersection (class).
vader-interval-index (class).
vader-inverse-where (class).
vader-matrix-divide (class).
vader-matrix-inverse (class).
vader-membership (class).
vader-mix (class).
vader-pare (class).
vader-partition (class).
vader-permute (class).
vader-pick (class).
vader-random (class).
vader-reshape (class).
vader-section (class).
vader-select (class).
vader-shape (class).
vader-split (class).
vader-subarray (class).
vader-subarray-displaced (class).
vader-turn (class).
vader-umask (class).
vader-union (class).
vader-unique (class).
vader-where (class).
vader-without (class).
vapri-apro-vector (class).
vapri-coordinate-identity (class).
vapri-onehot-vector (class).
varray (class).
varray-compare (function).
varrayp (function).
vrender (function).
*april-parallel-kernel* (special variable).
*package-name-string* (special variable).
*workers-count* (special variable).
apl-array-prototype (function).
apl-random-process (function).
arg-process (function).
assign-reference (generic function).
ava-dimension (type).
ava-rank (type).
ava-size (type).
ava-worker-count (type).
build-decoder (function).
build-decoder-x86asm (function).
build-encoder (function).
build-encoder-x86asm (function).
build-iterator (function).
build-iterator-x86asm (function).
decode-rmi (function).
effect (generic function).
effector-of (generic function).
encode-rmi (function).
extend-allocator-vader-calculate (function).
extend-allocator-vader-expand (function).
extend-allocator-vader-inverse-where (function).
extend-allocator-vader-permute (function).
extend-allocator-vader-section (function).
fast-iota-sum (function).
fast-iota-sum-fixnum (type).
fetch-reference (generic function).
get-dimensional-factors (function).
get-indexing-function (function).
get-or-assign-shape (macro).
get-path-value (function).
get-promised (macro).
get-reduced (generic function).
incrementer-encoded (function).
indexer-of (generic function).
indexer-permute (function).
indexer-section (function).
indexer-turn (function).
intraverser (macro).
iota-sum (function).
join-indexers (function).
linear-regression (function).
make-threading-kernel-if-absent (function).
mask-signed (function).
matrix-divide (function).
metadata-of (generic function).
nested-base (function).
nested-p (function).
prototype-of (generic function).
render (generic function).
segment-length (function).
side-effect-free (function).
specify (generic function).
sub-byte-element-type (function).
sub-indexer-of (generic function).
va-class (class).
vacat-laminating (generic reader).
(setf vacat-laminating) (generic writer).
vacmp-alpha (generic reader).
(setf vacmp-alpha) (generic writer).
vacmp-async (generic reader).
(setf vacmp-async) (generic writer).
vacmp-left (generic reader).
(setf vacmp-left) (generic writer).
vacmp-omega (generic reader).
(setf vacmp-omega) (generic writer).
vacmp-right (generic reader).
(setf vacmp-right) (generic writer).
vacov-index (generic reader).
(setf vacov-index) (generic writer).
vacov-reference (generic reader).
(setf vacov-reference) (generic writer).
vacred-unitary (generic reader).
(setf vacred-unitary) (generic writer).
vacst-base-dims (generic reader).
(setf vacst-base-dims) (generic writer).
vacst-in-factors (generic reader).
(setf vacst-in-factors) (generic writer).
vacst-movement (generic reader).
(setf vacst-movement) (generic writer).
vacst-out-factors (generic reader).
(setf vacst-out-factors) (generic writer).
vacst-win-dims (generic reader).
(setf vacst-win-dims) (generic writer).
vacst-win-factors (generic reader).
(setf vacst-win-factors) (generic writer).
vacst-win-offsets (generic reader).
(setf vacst-win-offsets) (generic writer).
vad-invertable (class).
vad-limitable (class).
vad-maybe-shapeless (class).
vad-nested (class).
vad-on-axis (class).
vad-reindexing (class).
vad-render-mutable (class).
vad-with-argument (class).
vad-with-ct (class).
vad-with-default-axis (class).
vad-with-dfactors (class).
vad-with-io (class).
vad-with-rng (class).
vadeal-cached (generic reader).
(setf vadeal-cached) (generic writer).
vader-base (generic reader).
(setf vader-base) (generic writer).
vader-content (generic reader).
(setf vader-content) (generic writer).
vader-layer (generic reader).
(setf vader-layer) (generic writer).
vader-stencil-margin (class).
vader-stencil-window (class).
vader-subarray-reduce (class).
vader-subarray-split (class).
vadex-separating (generic reader).
(setf vadex-separating) (generic writer).
vads-argument (generic reader).
(setf vads-argument) (generic writer).
vads-axis (generic reader).
(setf vads-axis) (generic writer).
vads-ct (generic reader).
(setf vads-ct) (generic writer).
vads-default-axis (generic reader).
(setf vads-default-axis) (generic writer).
vads-dfactors (generic reader).
(setf vads-dfactors) (generic writer).
vads-inverse (generic reader).
(setf vads-inverse) (generic writer).
vads-io (generic reader).
(setf vads-io) (generic writer).
vads-nested (generic reader).
(setf vads-nested) (generic writer).
vads-rendered (generic reader).
(setf vads-rendered) (generic writer).
vads-rng (generic reader).
(setf vads-rng) (generic writer).
vads-shapeset (generic reader).
(setf vads-shapeset) (generic writer).
vaenc-inner-shape (generic reader).
(setf vaenc-inner-shape) (generic writer).
vafind-cached (generic reader).
(setf vafind-cached) (generic writer).
vafind-pattern (generic reader).
(setf vafind-pattern) (generic writer).
vaix-cache (generic reader).
(setf vaix-cache) (generic writer).
vaix-set (generic reader).
(setf vaix-set) (generic writer).
vamem-to-search (generic reader).
(setf vamem-to-search) (generic writer).
vamix-cached-elements (generic reader).
(setf vamix-cached-elements) (generic writer).
vamix-shape-indices (generic reader).
(setf vamix-shape-indices) (generic writer).
vaohv-index (generic reader).
(setf vaohv-index) (generic writer).
vaop-function (generic reader).
(setf vaop-function) (generic writer).
vaop-params (generic reader).
(setf vaop-params) (generic writer).
vaop-sub-shape (generic reader).
(setf vaop-sub-shape) (generic writer).
vapart-params (generic reader).
(setf vapart-params) (generic writer).
vapci-shape (generic reader).
(setf vapci-shape) (generic writer).
vaperm-is-diagonal (generic reader).
(setf vaperm-is-diagonal) (generic writer).
vapick-apath-index (generic reader).
(setf vapick-apath-index) (generic writer).
vapick-assign (generic reader).
(setf vapick-assign) (generic writer).
vapick-function (generic reader).
(setf vapick-function) (generic writer).
vapick-reference (generic reader).
(setf vapick-reference) (generic writer).
vapick-selector (generic reader).
(setf vapick-selector) (generic writer).
vapip-factor (generic reader).
(setf vapip-factor) (generic writer).
vapip-number (generic reader).
(setf vapip-number) (generic writer).
vapip-offset (generic reader).
(setf vapip-offset) (generic writer).
vapip-origin (generic reader).
(setf vapip-origin) (generic writer).
vapip-repeat (generic reader).
(setf vapip-repeat) (generic writer).
vapri-axis-vector (class).
vapri-coordinate-vector (class).
varray-depth (function).
varray-derived (class).
varray-generator (generic reader).
(setf varray-generator) (generic writer).
varray-meta (generic reader).
(setf varray-meta) (generic writer).
varray-primal (class).
varray-prototype (generic reader).
(setf varray-prototype) (generic writer).
varray-shape (generic reader).
(setf varray-shape) (generic writer).
vasbr-delta (generic reader).
(setf vasbr-delta) (generic writer).
vasbr-reverse (generic reader).
(setf vasbr-reverse) (generic writer).
vasbr-window (generic reader).
(setf vasbr-window) (generic writer).
vasbs-core-indexer (generic reader).
(setf vasbs-core-indexer) (generic writer).
vasec-pad (generic reader).
(setf vasec-pad) (generic writer).
vasec-span (generic reader).
(setf vasec-span) (generic writer).
vasel-assign (generic reader).
(setf vasel-assign) (generic writer).
vasel-assign-if (generic reader).
(setf vasel-assign-if) (generic writer).
vasel-assign-shape (generic reader).
(setf vasel-assign-shape) (generic writer).
vasel-calling (generic reader).
(setf vasel-calling) (generic writer).
vasel-selector (generic reader).
(setf vasel-selector) (generic writer).
vaste-index (generic reader).
(setf vaste-index) (generic writer).
vastw-index (generic reader).
(setf vastw-index) (generic writer).
vasv-index (generic reader).
(setf vasv-index) (generic writer).
vaturn-degrees (generic reader).
(setf vaturn-degrees) (generic writer).
vauni-indices (generic reader).
(setf vauni-indices) (generic writer).
vaxv-axis (generic reader).
(setf vaxv-axis) (generic writer).
vaxv-index (generic reader).
(setf vaxv-index) (generic writer).
vaxv-reference (generic reader).
(setf vaxv-reference) (generic writer).
vaxv-window (generic reader).
(setf vaxv-window) (generic writer).
maxpc.input.streamImplements support for _input sources_ of _type_ {stream}. Input from _streams_ is copied into a temporary buffer lazily as required by the parser. _Streams_ of _type_ {file-stream} are read in as chunks of customizable size.
common-lisp.
maxpc.input.
maxpc.input.index.
*bound* (special variable).
*chunk-size* (special variable).
*element-type* (special variable).
copy-index-stream (function).
element-type (function).
fill-buffer (generic function).
index-stream (structure).
index-stream-buffer (reader).
index-stream-p (function).
index-stream-position (function).
index-stream-stream (reader).
make-index-stream (function).
maybe-fill-buffer (function).
maxpc.inputThe generic _input_ interface allows extensions to parse other _types_ of
_input sources_. To add a new _input source type_, {make-input} has to be
specialized on that _type_. The following methods have to be defined for
_inputs_:
+ {input-empty-p}
+ {input-first}
+ {input-rest}
The following methods can optionally be defined for _inputs_:
+ {input-position}
+ {input-element-type}
+ {input-sequence}
common-lisp.
input-element-type (generic function).
input-empty-p (generic function).
input-first (generic function).
input-position (generic function).
input-rest (generic function).
input-sequence (generic function).
make-input (generic function).
maxpc.digitParsers for digit numerals in character inputs.
common-lisp.
maxpc.
=integer-number (function).
=natural-number (function).
?digit (function).
aprilapril (macro).
april-c (macro).
april-clear-workspace (macro).
april-create-workspace (macro).
april-f (macro).
april-load (macro).
april-print-progress-bar (function).
with-april-context (macro).
*alphabet-vector* (special variable).
*apl-timestamp* (symbol macro).
*april-idiom* (special variable).
*branches* (symbol macro).
*demo-packages* (special variable).
*digit-vector* (special variable).
*first-axis* (symbol macro).
*first-axis-or-nil* (symbol macro).
*function-identities* (special variable).
*idiom-native-symbols* (special variable).
*io-currying-function-symbols-dyadic* (special variable).
*io-currying-function-symbols-monadic* (special variable).
*last-axis* (symbol macro).
*lib-tests-failed* (special variable).
*lib-tests-run* (special variable).
*library-packages* (special variable).
*package-name-string* (special variable).
*rng-names* (special variable).
*system-variables* (special variable).
*value-composable-lexical-operators* (special variable).
a-call (macro).
a-comp (macro).
a-out (macro).
a-set (macro).
ac-wrap (macro).
achoose (macro).
add-aprepl-load-to-emacs-init-file (function).
adjust-axes-for-index-origin (function).
alambda (macro).
amb-ref (macro).
apl-ceiling (function).
apl-divide (function).
apl-exp (function).
apl-expt (function).
apl-floor (function).
apl-fn (macro).
apl-fn-s (macro).
apl-gcd (function).
apl-if (macro).
apl-lcm (function).
apl-log (function).
apl-random (function).
apl-random-process (function).
apl-residue (function).
apl-timestamp (function).
apl-xcy (function).
aprgn (macro).
april-lex-fn-! (special variable).
april-lex-fn-! (function).
april-lex-fn-* (special variable).
april-lex-fn-* (function).
april-lex-fn-+ (special variable).
april-lex-fn-+ (function).
april-lex-fn-, (special variable).
april-lex-fn-, (function).
april-lex-fn-- (special variable).
april-lex-fn-- (function).
april-lex-fn-/ (special variable).
april-lex-fn-/ (function).
april-lex-fn-< (special variable).
april-lex-fn-< (function).
april-lex-fn-= (special variable).
april-lex-fn-= (function).
april-lex-fn-> (special variable).
april-lex-fn-> (function).
april-lex-fn-? (special variable).
april-lex-fn-? (function).
april-lex-fn-\ (special variable).
april-lex-fn-\ (function).
april-lex-fn-^ (special variable).
april-lex-fn-^ (function).
april-lex-fn-| (special variable).
april-lex-fn-| (function).
april-lex-fn-~ (special variable).
april-lex-fn-~ (function).
april-lex-fn-× (special variable).
april-lex-fn-× (function).
april-lex-fn-÷ (special variable).
april-lex-fn-÷ (function).
april-lex-fn-↑ (special variable).
april-lex-fn-↑ (function).
april-lex-fn-↓ (special variable).
april-lex-fn-↓ (function).
april-lex-fn-∊ (special variable).
april-lex-fn-∊ (function).
april-lex-fn-∧ (special variable).
april-lex-fn-∧ (function).
april-lex-fn-∨ (special variable).
april-lex-fn-∨ (function).
april-lex-fn-∩ (special variable).
april-lex-fn-∩ (function).
april-lex-fn-∪ (special variable).
april-lex-fn-∪ (function).
april-lex-fn-≠ (special variable).
april-lex-fn-≠ (function).
april-lex-fn-≡ (special variable).
april-lex-fn-≡ (function).
april-lex-fn-≢ (special variable).
april-lex-fn-≢ (function).
april-lex-fn-≤ (special variable).
april-lex-fn-≤ (function).
april-lex-fn-≥ (special variable).
april-lex-fn-≥ (function).
april-lex-fn-⊂ (special variable).
april-lex-fn-⊂ (function).
april-lex-fn-⊃ (special variable).
april-lex-fn-⊃ (function).
april-lex-fn-⊆ (special variable).
april-lex-fn-⊆ (function).
april-lex-fn-⊖ (special variable).
april-lex-fn-⊖ (function).
april-lex-fn-⊢ (special variable).
april-lex-fn-⊢ (function).
april-lex-fn-⊣ (special variable).
april-lex-fn-⊣ (function).
april-lex-fn-⊤ (special variable).
april-lex-fn-⊤ (function).
april-lex-fn-⊥ (special variable).
april-lex-fn-⊥ (function).
april-lex-fn-⋆ (special variable).
april-lex-fn-⋆ (function).
april-lex-fn-⌈ (special variable).
april-lex-fn-⌈ (function).
april-lex-fn-⌊ (special variable).
april-lex-fn-⌊ (function).
april-lex-fn-⌷ (special variable).
april-lex-fn-⌷ (function).
april-lex-fn-⌹ (special variable).
april-lex-fn-⌹ (function).
april-lex-fn-⌽ (special variable).
april-lex-fn-⌽ (function).
april-lex-fn-⌿ (special variable).
april-lex-fn-⌿ (function).
april-lex-fn-⍀ (special variable).
april-lex-fn-⍀ (function).
april-lex-fn-⍉ (special variable).
april-lex-fn-⍉ (function).
april-lex-fn-⍋ (special variable).
april-lex-fn-⍋ (function).
april-lex-fn-⍎ (special variable).
april-lex-fn-⍎ (function).
april-lex-fn-⍒ (special variable).
april-lex-fn-⍒ (function).
april-lex-fn-⍕ (special variable).
april-lex-fn-⍕ (function).
april-lex-fn-⍟ (special variable).
april-lex-fn-⍟ (function).
april-lex-fn-⍪ (special variable).
april-lex-fn-⍪ (function).
april-lex-fn-⍱ (special variable).
april-lex-fn-⍱ (function).
april-lex-fn-⍲ (special variable).
april-lex-fn-⍲ (function).
april-lex-fn-⍳ (special variable).
april-lex-fn-⍳ (function).
april-lex-fn-⍴ (special variable).
april-lex-fn-⍴ (function).
april-lex-fn-⍷ (special variable).
april-lex-fn-⍷ (function).
april-lex-fn-⍸ (special variable).
april-lex-fn-⍸ (function).
april-lex-fn-○ (special variable).
april-lex-fn-○ (function).
april-lex-op-. (special variable).
april-lex-op-. (function).
april-lex-op-/ (special variable).
april-lex-op-/ (function).
april-lex-op-@ (special variable).
april-lex-op-@ (function).
april-lex-op-\ (special variable).
april-lex-op-\ (function).
april-lex-op-¨ (special variable).
april-lex-op-¨ (function).
april-lex-op-∘ (special variable).
april-lex-op-∘ (function).
april-lex-op-⌸ (special variable).
april-lex-op-⌸ (function).
april-lex-op-⌺ (special variable).
april-lex-op-⌺ (function).
april-lex-op-⌿ (special variable).
april-lex-op-⌿ (function).
april-lex-op-⍀ (special variable).
april-lex-op-⍀ (function).
april-lex-op-⍛ (special variable).
april-lex-op-⍛ (function).
april-lex-op-⍣ (special variable).
april-lex-op-⍣ (function).
april-lex-op-⍤ (special variable).
april-lex-op-⍤ (function).
april-lex-op-⍥ (special variable).
april-lex-op-⍥ (function).
april-lex-op-⍨ (special variable).
april-lex-op-⍨ (function).
april-lex-st-$ (special variable).
april-lex-st-$ (function).
april-lex-st-⍢ (special variable).
april-lex-st-⍢ (function).
april-lex-sy-∶ (special variable).
april-lex-sy-← (special variable).
april-lex-sy-→ (special variable).
april-lex-sy-∘ (special variable).
april-lex-vfn-* (special variable).
april-lex-vfn-^ (special variable).
april-ref (function).
array-setting-meta (function).
array-to-nested-vector (function).
assign-by-selection (function).
at-index (function).
at-path (function).
avec (function).
binary-not (function).
build-axes (function).
build-call-form (function).
build-compiled-code (function).
build-function (function).
build-operator (function).
build-populator (function).
build-value (function).
build-variable-declarations (function).
call-circular (function).
change-namespace (function).
check-value (function).
cmucl-complex-acos (function).
coerce-or-get-type (function).
compare-by (function).
compile-form (function).
complete-branch-composition (function).
complete-pivotal-match (function).
complete-value-assignment (function).
complex-floor (function).
compose-function-assignment (function).
compose-function-lateral (function).
compose-function-pivotal (function).
compose-function-train (function).
compose-value-assignment (function).
count-cpus (function).
count-to (function).
disclose-atom (function).
display-banner (function).
dummy-nargument-function (function).
dummy-operator (function).
enclose-axes (function).
external-workspace-function (function).
external-workspace-operator (function).
external-workspace-value (function).
extract-axes (function).
f-lex (macro).
fn-meta (macro).
fnexp-backup (function).
follow-path (function).
format-array (function).
format-array-uncollated (function).
format-nspath (function).
format-value (function).
function-variant (macro).
generate-index-array (function).
get-array-meta (function).
get-assigned-symbols (function).
in-april-workspace (macro).
indent-code (function).
insym (macro).
inv-fn (macro).
invert-assigned-varray (function).
invert-function (function).
is-alphanumeric (function).
is-workspace-function (macro).
is-workspace-operator (macro).
is-workspace-value (macro).
lexer-postprocess (function).
life (function).
load-libs (function).
make-namespace (function).
make-prototype-of (function).
make-virtual (macro).
nspath (macro).
of-meta-hierarchy (function).
olambda (macro).
operate-at (function).
operate-at-rank (function).
operate-atop (function).
operate-before (function).
operate-beside (function).
operate-commuting (function).
operate-each (function).
operate-grouping (function).
operate-producing-outer (function).
operate-stenciling (function).
operate-to-power (function).
output-function (function).
output-value (function).
parse-apl-number-string (function).
plain-ref (macro).
print-and-run (macro).
print-apl-number-string (function).
process-fnspecs (function).
process-function (function).
process-ns-output (function).
process-operator (function).
process-output-vector (function).
process-path (function).
process-value (function).
reg-side-effect (function).
reg-symfn-call (function).
resolve-function (function).
resolve-path (function).
run-lib-tests (macro).
sb-rationalize (function).
scalar-code-char (function).
scalar-compare (function).
scalar-function (macro).
set-array-meta (function).
set-namespace-point (function).
side-effect-free (function).
specify-demo (macro).
sub-aliasing (macro).
sub-lex (macro).
system-command-exists (function).
this-idiom (symbol macro).
value-meta-process (macro).
without (function).
λχ (macro).
λω (macro).
λωα (macro).
λωαχ (macro).
λωχ (macro).
∇ (special variable).
∇∇ (special variable).
maxpc.input.vectorcommon-lisp.
maxpc.input.
maxpc.input.index.
copy-index-simple-string (function).
copy-index-simple-vector (function).
copy-index-vector (function).
index-simple-string (structure).
index-simple-string-p (function).
index-simple-string-position (function).
index-simple-string-vector (function).
index-simple-vector (structure).
index-simple-vector-p (function).
index-simple-vector-position (function).
index-simple-vector-vector (function).
index-vector (structure).
index-vector-p (function).
index-vector-position (function).
index-vector-vector (reader).
make-index-simple-string (function).
make-index-simple-vector (function).
make-index-vector (function).
maxpc.input.listcommon-lisp.
maxpc.input.
maxpc.input.index.
copy-index-list (function).
index-list (structure).
index-list-list (reader).
index-list-p (function).
index-list-position (function).
make-index-list (function).
maxpc_Max’s Parser Combinators_¹ is a simple and pragmatic library for writing
parsers and lexers based on combinatory parsing. MaxPC is capable of
parsing deterministic, context-free languages, provides powerful tools for
parse tree transformation and error handling, and can operate on
_sequences_ and _streams_. It supports unlimited backtracking, but does not
implement [Packrat Parsing](http://pdos.csail.mit.edu/~baford/packrat/thesis/).
Instead, MaxPC achieves good performance through its optimized primitives,
and explicit separation of matching and capturing input. In practice, MaxPC
parsers perform better on typical computer languages—when compared to
Packrat parsers—at the expense of not producing linear-time parsers.²
+ 1. MaxPC is a complete rewrite of [MPC](https://github.com/eugeneia/mpc)
with was in turn a fork of Drew Crampsie’s
[Smug](http://smug.drewc.ca/).
+ 2. See [MaxPC: Why? How? / Packrat Parsing](http://mr.gy/blog/maxpc.html#section-3-1)
on why the book keeping costs of Packrat parsing diminish the gain in
execution time for typical grammars and workloads.
< Basic Concepts
MaxPC _parsers_ are _functions_ that accept an [input](#section-4) as
their only argument and return three values: the remaining _input_ or
{nil}, a _result value_ or {nil}, and a _generalized boolean_ that
indicates if a _result value_ is present. The _type_ of a parser is:
{(function (}_input_{) (or} _input_ {null) * boolean)}
A parser can either succeed or fail when applied to an input at a given
position. A succeeding parser is said to _match_. When a parser matches it
can optionally produce a _result value_, which may be processed by its
parent parsers. New parsers can be created by composing existing parsers
using built-in or user defined _parser combinators_. A parser combinator
is a higher-order _function_ that includes one or more parsers as its
arguments and returns a parser.
By convention, all parsers are defined as higher-order _functions_ that
return the respective parser, even if they are nullary. For instance, the
{?end} parser is obtained using the form “{(?end)}”.
A lexical convention is used to make three different types of parsers
easily distinguishable:
+ Parsers whose names start with a question mark ({?}) never produce a
result value.
+ Parsers whose names start with an equals sign ({=}) always produce a
result value.
+ Parsers whose names start with a percent symbol ({%}) may produce a
result value depending on their arguments.
>
< Example
We will define a parser for a simplistic grammar for Email addresses of
the form:
_email‑address_ := _user_ {@} _host_
First we define a parser for the valid characters in the _user_ and _host_
parts of an address. Just for this example, we choose these to be
alphanumeric characters and then some. {?address-character} uses the {%or}
combinator to form the union of two instances of {?satisfies} that match
different sets of characters.
#code#
(defun ?address-character ()
(%or (?satisfies ’alphanumericp)
(?satisfies (lambda (c)
(member c ’(#\- #\_ #\. #\+))))))
#
Then we use {?address-character} to implement our address parser which
matches two sequences of “address characters” separated by an {@}
character, and produces a list of user and host components as its result
value. We match {?address-character} one or more times using {%some}, and
produce the matched subsequence as the result value using {=subseq}. Both
parts of the address separated by an _@_ character are matched in sequence
using {=list}, whose result value is finally transformed by
{=destructure}.
#code#
(defun =email-address ()
(=destructure (user _ host)
(=list (=subseq (%some (?address-character)))
(?eq #\@)
(=subseq (%some (?address-character))))
(list user host)))
#
We can now apply {=email-address} using {parse}:
#code#
(parse "foo_bar@example.com" (=email-address))
⇒ ("foo_bar" "example.com"), T, T
(parse "!!!@@@.com" (=email-address))
⇒ NIL, NIL, NIL
(parse "foo_bar@example.com@baz" (=email-address))
⇒ ("foo_bar" "example.com"), T, NIL
#
>
< Overview
{parse} is the entry point of {MaxPC}. It applies a parser to an input and
returns the parser’s result value, and two _boolean_ values indicating if
the parser matched and if there is unmatched input remaining,
respectively.
< Basic Parsers
+ {?end} matches only when there is no further input.
+ {=element} unconditionally matches the next element of the input
_sequence_.
+ {=subseq} produces the subsequence matched by its argument as its
result value.
+ {?satisfies}, {?test}, and {?eq} match input conditionally.
+ {%maybe} matches, even if its argument fails to match.
>
< Logical Combinators
+ {%or} forms the union of its arguments.
+ {%and} forms the intersection of its arguments.
+ {%diff} forms the difference of its arguments.
+ {?not} negates its argument.
>
< Sequence Combinators
+ {?seq} matches its arguments in sequence.
+ {=list} matches its arguments in sequence and produces a list of their
results as its result value.
+ {%any} matches its argument repeatedly any number of times.
+ {%some} matches its argument repeatedly one or more times.
>
< Transformation
+ {=transform} produces the result of applying a _function_ to its
argument’s result value as its result value.
+ {=destructure} is a convenient destructuring _macro_ on top of
{=transform}.
>
< Error Handling
+ {?fail} never matches and evaluates its body when it is called.
+ {%handler-case} and {%restart-case} allow you to set up _handlers_ and
_restarts_ across parsers.
+ {get-input-position} can be called in error situations to retrieve the
current position in the input.
>
>
< Caveat: Recursive Parsers
A recursive parser can not refer to itself by its constructor, but must
instead call itself by _symbol_—calling its constructor would otherwise
result in unbounded recursion. In order to do so the parser _function_
needs to be _bound_ in the _function namespace_ using {setf}. The example
below implements a parser for balanced parentheses, and illustrates how to
avoid this common caveat.
#code#
(defun ?parens ()
(?seq (?eq #\() (%maybe ’?parens/parser) (?eq #\))))
(setf (fdefinition ’?parens/parser) (?parens))
(parse "((()))" (?parens)) ⇒ NIL, T, T
#
>
common-lisp.
maxpc.input.
%and (function).
%any (function).
%diff (function).
%handler-case (macro).
%maybe (function).
%or (function).
%restart-case (macro).
%some (function).
=destructure (macro).
=element (function).
=list (function).
=subseq (function).
=transform (function).
?end (function).
?eq (function).
?fail (macro).
?not (function).
?satisfies (function).
?seq (function).
?test (macro).
get-input-position (function).
parse (function).
*input-fail* (special variable).
*input-start* (special variable).
cases-to-parser-cases (function).
parse-line-position (function).
aplesquecommon-lisp.
across (function).
alpha-compare (function).
apl-array-prototype (function).
apply-scalar (function).
array-compare (function).
array-depth (function).
array-grade (function).
array-impress (function).
array-inner-product (function).
array-outer-product (function).
array-promote (function).
array-to-list (function).
assign-element-type (function).
binomial (function).
catenate (function).
choose (function).
copy-nested-array (function).
count-segments (function).
disclose (function).
disclose-unitary (function).
duplicate (function).
enclose (function).
enclose-atom (function).
enlist (function).
expand (function).
find-array (function).
get-dimensional-factors (function).
get-first-or-disclose (function).
grade (function).
index-of (function).
interval-index (function).
inverse-outer-product (function).
invert-matrix (function).
is-integer-array (function).
is-unitary (function).
laminate (function).
left-invert-matrix (function).
make-empty-array (function).
matrix-print (macro).
mix-arrays (function).
nest (function).
partition-array (function).
partitioned-enclose (function).
permute-axes (function).
ravel (function).
re-enclose (function).
reduce-array (function).
reshape-to-fit (function).
scale-array (function).
section (function).
split-array (function).
sprfact (function).
stencil (function).
turn (function).
type-in-common (function).
varef (function).
(setf varef) (function).
xdotimes (macro).
ydotimes (macro).
*sub-7-bit-element-processing-register-size* (special variable).
axes-to-indices (function).
gamma (function).
get-free-threads (function).
ibinomial (function).
indexer-enclose (function).
indexer-expand (function).
indexer-permute (function).
indexer-section (function).
indexer-split (function).
indexer-turn (function).
isprfact (function).
near-integerp (function).
near-realp (function).
rmi-convert (function).
rmi-from-subscript-vector (function).
sub-7-bit-integer-elements-p (function).
vector-grade (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
*Description:*
{*bound*} can be set to limit the number of elements read from _stream inputs_ in a single call to to {parse}.
*Description:*
{*chunk-size*} controls the size by which the buffer used for _stream inputs_ grows, and the number of elements read at a time when parsing from _streams_ of _type_ {file-stream}.
*Description:*
{*element-type*} can be set to enforce a specific stream element type when reading from _stream inputs_. This can be useful when dealing with bivalent streams.
*Value Type:*
a _list_ of _characters_.
*Description:*
The _value_ of {*whitespace*} is a _list_ of _characters_ considered to be _whitespace characters_.
_clauses_::= {{}↓_error‑clause_{\}}\*
_error‑clause_::=
{(}_typespec_ {([}_var_{])}
{{}_declaration_{\}}\* {{}_form_{\}}\* _parser‑form_{)}
*Arguments and Values:*
_parser_—a _parser_.
_typespec_—a _type specifier_.
_var_—a _variable name_.
_declaration_—a {declare} _expression_; not evaluated.
_form_—a _form_.
_parser‑form_—a _form_ that evaluates to a _parser_.
*Description:*
{%handler-case} executes _parser_ in a _dynamic environment_ where handlers
are active as if by {handler-case}. If a _condition_ is handled by
{%handler-case}, _parser‑form_ is evaluated and the resulting _parser_ is
applied.
*Examples:*
#code#
(defun assert-digit (c)
(or (digit-char-p c)
(error "Not a digit: ~c" c)))
(parse "01x2"
(%any (%handler-case (%and (?satisfies ’assert-digit)
(=element))
(error (e)
(format t "Error at position ~a: ~a~%"
(get-input-position) e)
(?seq (=element))))))
▷ Error at position 2: Not a digit: x
→ (#\0 #\1 #\2), T, T
#
*See Also:*
{handler-case}.
_clauses_::= {{}↓_restart‑clause_{\}}\*
_restart‑clause_::=
{(}_case‑name_ {([}_lambda‑list_{])}
〚{:interactive} _interactive‑expression_ |
{:report} _report‑expression_ |
{:test} _test‑expression_〛
{{}_declaration_{\}}\* {{}_form_{\}}\* _parser‑form_{)}
*Arguments and Values:*
_parser_—a _parser_.
_case‑name_—a _symbol_ or {nil}.
_lambda‑list_—an _ordinary lambda list_.
_interactive‑expression_—a _symbol_ or a _lambda expression_.
_report‑expression_—a _string_, a _symbol_, or a _lambda expression_.
_test‑expression_—a _symbol_ or a _lambda expression_.
_declaration_—a {declare} _expression_; not evaluated.
_form_—a _form_.
_parser‑form_—a _form_ that evaluates to a _parser_.
*Description:*
{%restart-case} executes _parser_ in a _dynamic environment_ where restarts
are active as if by {restart-case}. If control is transferred to a
_restart‑clause_, _parser‑form_ is evaluated and the resulting _parser_ is
applied.
*Examples:*
#code#
(parse "012x3"
(%any (%restart-case
(=transform
(=element)
(lambda (c)
(if (digit-char-p c)
c
(error "Not a digit: ~c" c))))
(skip-element ()
:report "Skip character."
(?seq (=element))))))
▷ Error: Not a digit: x
▷ To continue, type :CONTINUE followed by an option number:
▷ 1: Skip non-digit character.
▷ 2: Return to Lisp Toplevel.
▷ Debug> :continue 1
▷ Invoking restart: Skip character.
→ (#\0 #\1 #\2), T, T
#
*See Also:*
{restart-case}.
*Arguments and Values:*
_lambda‑list_—a _destructuring lambda list_.
_parser_—a _parser_.
_forms_—an _implicit progn_.
*Description:*
{=destructure} matches _parser_ and destructures its result value as if by
{destructuring-bind}. The {_} (underscore) symbol can occur in _lambda‑list_
any number of times, and is substituted with a _fresh_, _uninterned symbol_
and declared {ignorable}. If _parser_ matches {=destructure} evaluates
_forms_ and produces the value of the last _form_ as its result value. If no
_forms_ are supplied the value of the last, _interned_ variable defined in
_lambda‑list_ is produced as the result value instead.
*Examples:*
#code#
(parse ’(10 % 3) (=destructure (x _ y)
(=list (=element) (?eq ’%) (=element))
(mod x y)))
→ 1, T, T
(parse "a," (=destructure (x _)
(=list (=element) (?eq #\,))))
→ #\a, T, T
(parse ’(a b c) (=destructure (x &rest xs)
(%some (=element))))
→ ’(B C), T, T
#
*Exceptional Situations:*
If the result value of _parser_ does not match the destructuring pattern, an
_error_ of _type_ {program-error} is signaled.
*See Also:*
{destructuring-bind}
*Arguments and Values:*
_forms_—_forms_.
*Description:*
{?fail} always fails to match, and evaluates _forms_ when it is applied.
*Examples:*
#code#
(parse ’(a b c) (?fail (format t "Position: ~a~%"
(get-input-position))))
▷ Position: 0
→ NIL, NIL, NIL
#
*Arguments and Values:*
_test_—a _designator_ for a _function_ that returns a _generalized boolean_.
_arguments_—_objects_.
_parser_—a _parser_. The default is {(=element)}.
*Description:*
{?test} matches _parser_ if its result value _satisfies the test_ with
_arguments_ as additional arguments to _test_.
*Examples:*
#code#
(parse ’(a) (?test (’member ’(a b)))) ⇒ NIL, T, T
(flet ((power-of-p (n e) (= (mod n e) 0)))
(parse ’(42) (?test (#’power-of-p 2)))) ⇒ NIL, T, T
#
*Notes:*
#code#
(?test ({fun} {args}*}))
≡ (?satisfies (lambda (x)
(funcall {fun} x {args}*)))
#
*Exceptional Situations:*
If _test_ accepts less arguments than the number of _arguments_ plus one an
_error_ of _type_ {program-error} is signaled.
*See also:*
{?satisfies}
Wrap a boolean operation for use in a vector language, converting the t or nil it returns to 1 or 0.
Wraps the idiom-spec macro for an extension of a Vex idiom.
Print a character matrix generated by array-impress.
Wrap a function so as to reverse the arguments passed to it and (- 5 10) will thus result in 5.
Wraps the idiom-spec macro for an initial specification of a Vex idiom.
Assignment macro for use with (:store-fun) directive.
vex.
Assignment macro for use with (:store-val) directive.
vex.
Macro to perform array operations in parallel provisioning threads according to the type of array being assigned to.
As xdotimes, but no provision is made for integer arrays with elements smaller than 7 bits; these are processed single-threaded.
*Arguments and Values:*
_parsers_—_parsers_.
*Description:*
{%and} applies _parsers_, and matches the last _parser_ only if all previous
_parsers_ succeed. If the last _parser_ produces a result value then {%and}
produces that value as its result value. It can be said that {%and} forms
the set intersection of _parsers_.
*Examples:*
#code#
(parse ’(:foo) (%and (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, T, T
(parse ’(foo) (%and (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, NIL, NIL
(parse ’(foo) (%and))
→ NIL, NIL, NIL
(parse ’(foo) (%and (?satisfies ’symbolp)
(=element)))
→ FOO, T, T
(parse ’() (%and (%maybe (?fail (princ ’foo)))
(%maybe (?fail (princ ’bar)))
(%maybe (?fail (princ ’baz)))))
▷ FOOBARBAZ
→ NIL, T, T
#
*Arguments and Values:*
_parser_—a _parser_.
*Description:*
{%any} matches _parser_ in sequence any number of times. If _parser_
produces a result value and matches at least once then {%any} produces a
_list_ of the values as its result value.
*Examples:*
#code#
(parse ’(a b c) (%any (=element))) → (A B C), T, T
(parse ’() (%any (=element))) → NIL, T, T
#
*Arguments and Values:*
_parser_—a _parser_.
_not‑parsers_—_parsers_.
*Description:*
{%diff} matches _parser_ only if applying _not‑parsers_ fails. If _parser_
produces a result value then {%diff} produces that value as its result
value. It can be said that {%diff} forms the set difference of _parser_ and
the union of _not‑parsers_.
*Examples:*
#code#
(parse ’(foo) (%diff (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, T, T
(parse ’(:foo) (%diff (?satisfies ’symbolp)
(?satisfies ’keywordp)))
→ NIL, NIL, NIL
(parse ’(foo) (%diff (?satisfies ’symbolp)))
→ NIL, T, T
(parse ’(:foo) (%diff (?satisfies ’symbolp)))
→ NIL, T, T
#
*Arguments and Values:*
_parser_—a _parser_.
*Description:*
{%maybe} matches _parser_ or nothing all, but always succeeds. If _parser_
matches and produces a result value then {%maybe} produces that value as its
result value.
*Examples:*
#code#
(parse ’(a) (%maybe (=element))) → A, T, T
(parse ’() (%maybe (=element))) → NIL, T, T
(parse ’(42) (%maybe (?satisfies ’evenp))) → NIL, T, T
#
*Arguments and Values:*
_parsers_—_parsers_.
*Description:*
{%or} attempts to successfully apply _parsers_, and matches the first
succeeding _parser_, if any. If that _parser_ produces a result value then
{%or} produces that value as its result value. It can be said that {%or}
forms the set union of _parsers_.
*Examples:*
#code#
(parse ’(a) (%or (?eq ’a) (?eq ’b))) → NIL, T, T
(parse ’(b) (%or (?eq ’a) (?eq ’b))) → NIL, T, T
(parse ’(a) (%or)) → NIL, NIL, NIL
(parse ’(a) (%or (=element)
(?fail (format t "No element.~%"))))
→ A, T, T
(parse ’() (%or (?fail (princ ’foo))
(?fail (princ ’bar))
(?fail (princ ’baz))))
▷ FOOBARBAZ
→ NIL, NIL, T
#
*Arguments and Values:*
_parser_—a _parser_.
*Description:*
{%some} matches _parser_ in sequence one or more times. If _parser_ produces
a result value then {%some} produces a _list_ of the values as its result
value.
*Examples:*
#code#
(parse ’(a b c) (%some (=element))) → (A B C), T, T
(parse ’() (%some (=element))) → NIL, NIL, T
#
*Description:*
{=element} matches the next element and produces that element it as its
result value.
*Examples:*
#code#
(parse ’(a) (=element)) → A, T, T
(parse ’() (=element)) → NIL, NIL, T
#
*Arguments and Values:*
_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.
*Description:*
{=integer-number} matches one or more digit _characters_ in the specified
_radix_, optionally lead by a sign character, in sequence, and produces the
_integer_ represented by that sequence as its result value. The leading sign
can be {#\\+} and {#\\-} for positive and negative values respectively.
The default is a positive value.
*Examples:*
#code#
(parse "101010" (=integer-number 2)) → 42, T, T
(parse "+101010" (=integer-number 2)) → 42, T, T
(parse "-101010" (=integer-number 2)) → -42, T, T
(parse "x101010" (=integer-number 2)) → NIL, NIL, NIL
#
*Exceptional Situations:*
If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.
*Arguments and Values:*
_keep‑newline‑p_—a _generalized boolean_. The default is _false_.
*Description:*
{=line} matches zero or more _characters_ in sequence followed by a
{#\\Newline} _character_ or the end of input, and produces the _string_ of
_characters_ as its result value. The terminating {#\\Newline} _character_
is not included in _string_ unless _keep‑newline‑p_ is _true_.
*Examples:*
#code#
(parse (format nil "foo~%bar~%baz") (%any (=line)))
→ ("foo" "bar" "baz"), T, T
#
*Exceptional Situations:*
If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.
*Arguments and Values:*
_parsers_—_parsers_.
*Description:*
{=list} matches _parsers_ in sequence, and produces a _list_ of the result
values of _parsers_ as its result value.
*Examples:*
#code#
(parse ’(a) (=list (=element) (?end)))
→ (A NIL), T, T
(parse ’(a b) (=list (=element) (?end)))
→ NIL, NIL, NIL
(parse ’(a) (=list))
→ NIL, T, NIL
#
*Arguments and Values:*
_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.
*Description:*
{=natural-number} matches one or more digit _characters_ in the specified
_radix_ in sequence, and produces the natural _number_ represented by that
digit sequence as its result value.
*Examples:*
#code#
(parse "234" (=natural-number 2)) → NIL, NIL, NIL
(parse "101010" (=natural-number 2)) → 42, T, T
#
*Exceptional Situations:*
If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.
*Arguments and Values:*
_parser_—a _parser_.
*Description:*
{=subseq} matches _parser_, and produces the subsequence matched by _parser_
as its result value.
*Examples:*
#code#
(parse ’(1 2 3) (=subseq (%any (?satisfies ’numberp))))
→ (1 2 3), T, T
(parse "123" (=subseq (%any (?satisfies ’digit-char-p))))
→ "123" T, T
#
*Arguments and Values:*
_parser_—a _parser_.
_function_—a _designator_ for a _function_ of one argument.
*Description:*
{=transform} matches _parser_ and produces the result of applying _function_
to the result value of _parser_ as its result value.
*Examples:*
#code#
(parse ’(41) (=transform (=element) ’1+)) → 42, T, T
(parse ’() (=transform (=element) ’1+)) → NIL, NIL, T
#
*Arguments and Values:*
_char_—a _character_.
_case‑sensitive‑p_—a _generalized boolean_. The default is _true_.
*Description:*
{?char} matches _char_. {?char} is case sensitive unless _case‑sensitive‑p_
is _false_.
*Exceptional Situations:*
If the next element is not a _character_ an _error_ of _type_ {type-error} is signaled.
*Arguments and Values:*
_radix_—a _number_ of _type_ {(integer 2 36)}. The default is {10}.
*Description:*
{?digit} matches a single digit _character_ in the specified _radix_.
*Exceptional Situations:*
If the next element is not a _character_ an _error_ of _type_ {type-error} is signaled.
*Description:*
{?end} matches the end of input.
*Examples:*
#code#
(parse ’() (?end)) → NIL, T, T
(parse ’(a) (?end)) → NIL, NIL, NIL
#
*Arguments and Values:*
_x_—an _object_.
_parser_—a _parser_. The default is {(=element)}.
*Description:*
{?eq} matches _parser_ if its result value is {eq} to _x_.
*Examples:*
#code#
(parse ’(a) (?eq ’a)) ⇒ NIL, T, T
(parse ’(b) (?eq ’a)) ⇒ NIL, NIL, NIL
#
*See also:*
{?satisfies}
*Description:*
{?newline} matches the {#\\Newline} _character_.
*Arguments and Values:*
_parser_—a _parser_.
*Description:*
{?not} matches the next element unless _parser_ matches.
*Examples:*
#code#
(parse ’(:foo :baz) (?not (?seq (?eq :foo) (?eq :bar))))
→ NIL, T, NIL
(parse ’() (?not (?eq :baz))
→ NIL, NIL, NIL
#
*Arguments and Values:*
_test_—a _designator_ for a _function_ of one argument that returns a
_generalized boolean_.
_parser_—a _parser_. The default is {(=element)}.
*Description:*
{?satisfies} matches _parser_ if its result value _satisfies the test_.
*Examples:*
#code#
(parse ’(1) (?satisfies ’numberp)) → NIL, T, T
(parse ’(a) (?satisfies ’numberp)) → NIL, NIL, NIL
(parse ’(a b c)
(?satisfies (lambda (s)
(intersection s ’(b c d)))
(%any (=element))))
⇒ NIL, T, T
#
*Arguments and Values:*
_parsers_—_parsers_.
*Description:*
{?seq} matches _parsers_ in sequence.
*Examples:*
#code#
(parse ’(a) (?seq (=element) (?end)))
→ NIL, T, T
(parse ’(a b) (?seq (=element) (?end)))
→ NIL, NIL, NIL
(parse ’(a) (?seq))
→ NIL, T, NIL
#
*Arguments and Values:*
_string_—a _string_.
_case‑sensitive‑p_—a _generalized boolean_. The default is _true_.
*Description:*
{?string} matches the _characters_ in _string_ in sequence. {?string} is
case sensitive unless _case‑sensitive‑p_ is _false_.
*Exceptional Situations:*
If an element attempted to be matched is not a _character_ an _error_ of _type_ {type-error} is signaled.
*Description:*
{?whitespace} matches an element that is a member of {*whitespace*}.
*Exceptional Situations:*
If the next element is not a _character_ an _error_ of _type_ {type-error} is signaled.
Iterate across a range of elements in an array, with the option of specifying which elements within each dimension to process.
Compare the contents of a vector according to their positions in an array, as when comparing an array of letters by their positions in the alphabet.
Returns the default element for an array based on that array’s first element (its prototype in array programming terms); blank spaces in the case of a character prototype and zeroes for others.
Apply a scalar function over an array or arrays as appropriate for the shape of the argument(s).
Print a progress bar that will grow toward completion as a process advances.
Perform a deep comparison of two APL arrays, which may be multidimensional or nested.
Find the maximum depth of nested arrays within an array.
Grade an array.
Render the contents of an array into a character matrix or, if the collate option is taken, an array with sub-matrices of characters.
Find the inner product of two arrays with two functions.
Find the outer product of two arrays with a function.
Promote an array to the next rank. The existing content will occupy 1 unit of the new dimension.
Convert array to list.
Find a type suitable for an APL array to hold a given item.
Generalized binomial function. For complex and fractional numbers uses Gamma function.
Join two arrays along the specified axis.
Select indices from an array and return them in an array shaped according to the requested indices, with the option to elide indices and perform an operation on the values at the indices instead of just fetching them and return the entire altered array.
Copy an array along with nested sub-arrays within it.
Count the lengths of segments a number will be divided into when printed using (array-impress), within the context of a column’s existing segments if provided.
Disclose a scalar nested array.
If the argument is an array with only one member, disclose it, otherwise do nothing.
Return a copy of the argument if it is an array, otherwise pass the argument back.
Enclose an item as per APL’s [⊂ enclose].
Enclose non-array values, passing through arguments that are already arrays.
Create a vector containing all elements of the input array in ravel order, breaking down nested and multidimensional arrays.
Expand an input array as per a vector of degrees, with the option to manifest zero values in the degree array as zeroes in the output in place of the original input values or to omit the corresponding values altogether if the :compress-mode option is used.
Find instances of an array within a larger array.
Get the set of dimensional factors corresponding to a set of array dimensions.
Get the first element of an array or disclose the element of a 0-rank array.
→ _position_
→ _position_, _line_, _column_
*Arguments and Values:*
_position_, _column_—non-negative _integers_.
_line_—a positive _integer_.
*Description:*
{get-input-position} returns the number of elements read from the input so
far. Additionally, _line_ and _column_ positions are returned if the input’s
_element type_ is {character}. Lines are counted starting at one while
columns are counted starting from zero.
{get-input-position} may only be called from within the body of {?fail}, the
handlers of {%handler-case} or the restarts of {%restart-case}.
*Exceptional Situations:*
If {get-input-position} is not evaluated within the dynamic context of {?fail}, {%handler-case} or {%restart-case} an _error_ of _type_ {simple-error} is signaled.
Grade an array, using vector grading if 1-dimensional or decomposing the array into vectors and comparing those if multidimensional.
Find occurrences of members of one set in an array and create a corresponding array with values equal to the indices of the found values in the search set, or one plus the maximum possible found item index if the item is not found in the search set.
Find the locations of indices of an array between the indices of a reference array.
Find the inverse outer product of an array with a function and a given outer product argument.
Find the inverse of a square matrix.
Determine if an array is typed so as to hold only integers.
Check whether this array has only one member, returning true if the argument is not an array.
Join the two arrays along a new axis inserted before the specified axis, the new axis having a length of 2.
Perform left inversion of matrix. Used to implement [⌹ matrix inverse].
Makes a prototype version of an array.
Combine an array of nested arrays into a higher-rank array, removing a layer of nesting.
Enclose simple arrays and return nested arrays as-is.
→ _result_, _match‑p_, _end‑p_
*Arguments and Values:*
_input-source_—an _input source_.
_parser_—a parser.
_result_—an _object_.
_match‑p_, _end‑p_—_generalized booleans_.
*Description:*
{parse} applies _parser_ to the _input_ and returns the parser’s _result
value_ or {nil}. _Match‑p_ is _true_ if _parser_ _matched_ the
_input-source_. _End‑p_ is _true_ if _parser_ _matched_ the complete
_input-source_. _Input_ is derived from _input-source_ by using
{maxpc.input:make-input}.
{parse} accepts _input sources_ of _type_ {sequence} and {stream} out of the
box.
*See Also:*
[input](#section-4), [maxpc.input.stream](#section-5)
Split an array into an array of vectors divided according to an array of positions.
Enclose parts of an input array partitioned according to the ’positions’ argument.
Permute an array according to a given new order of axes. If axis order indices are repeated, a diagonal traversal of the dimensions with repeated order indices is indicated.
Produce a vector from the elements of a multidimensional array.
Convert an array into a set of sub-arrays within a larger array. The dimensions of the containing array and the sub-arrays will be some combination of the dimensions of the original array. For example, a 2 x 3 x 4 array may be composed into a 3-element vector containing 2 x 4 dimensional arrays.
Reduce an array along by a given function along a given dimension, optionally with a window interval.
Reshape an array into a given set of dimensions, truncating or repeating the elements in the array until the dimensions are satisfied if the new array’s size is different from the old.
Scale up a 1-element array to fill the dimensions of the given array.
Take a subsection of an array of the same rank and given dimensions as per APL’s [↑ take] function, or do the converse as per APL’s [↓ drop] function to take the elements of an array excepting a specific dimensional range.
Split an array into a set of sub-arrays.
Top-level factorial-computing function.
Apply a given function to sub-arrays of an array with specified dimensions sampled according to a given pattern of movement across the array.
Either reflect an array or rotate it a number of degrees along a given axis. Used to implement [⌽⊖ reflect/rotate].
Find a type for an array that may hold elements from arrays of a set of given types; effectively the most efficient compatible type among the array types.
Reference an element in an array according to a vector of subscripts.
Set an element in an array according to a vector of subscripts.
Perform a deep comparison of two APL arrays, which may be multidimensional or nested.
Compile a set of expressions, optionally drawing external variables into the program and setting configuration parameters for the system.
A public-facing interface to the render method.
Assign a rank at which to process a virtual array, implementing cases of function composition using the [⍤ rank] operator.
vader-permute) rank) ¶Assign a rank at which the [⍉ permute] function shall operate, for its composition with the [⍤ rank] operator.
vader-turn) rank) ¶Assign a rank at which the [⌽⊖ rotate] function shall operate, for its composition with the [⍤ rank] operator.
vad-on-axis) rank) ¶Assign a rank at which the [⌽⊖ rotate] function shall operate, for its composition with the [⍤ rank] operator.
The default case of rank assignment is to return nil.
Get the element type of an array.
vader-stencil-margin)) ¶vader-composing)) ¶vader-select)) ¶vader-calculate)) ¶vader-identity)) ¶vader-decode)) ¶vader-encode)) ¶vader-matrix-divide)) ¶vader-matrix-inverse)) ¶vader-grade)) ¶vader-union)) ¶vader-unique)) ¶vader-intersection)) ¶vader-pick)) ¶vader-partition)) ¶vader-enclose)) ¶vader-split)) ¶The [↓ split] function returns a nested array unless its argument is scalar.
vader-catenate)) ¶vader-interval-index)) ¶vader-where)) ¶vader-find)) ¶vader-membership)) ¶vader-compare)) ¶vader-first-dim)) ¶vader-depth)) ¶vader-shape)) ¶vader-index)) ¶vader-inverse-where)) ¶vader-umask)) ¶vader-without)) ¶vader-deal)) ¶vader-random)) ¶vapri-axis-vector)) ¶vapri-onehot-vector)) ¶Always a binary array.
vapri-coordinate-identity)) ¶Being a nested array, the type is always t.
vapri-coordinate-vector)) ¶The type of the coordinate vector.
vapri-apro-vector)) ¶varray-derived)) ¶The default shape of a derived array is the same as its base array.
array)) ¶A literal array’s element type is returned by the (array-element-type) function.
A literal array’s element type is returned by the (array-element-type) function.
Get a generating function for an array.
vacomp-stencil) &optional indexers params) ¶vader-stencil-margin) &optional indexers params) ¶vader-stencil-window) &optional indexers params) ¶vacomp-produce) &optional indexers params) ¶vader-subarray-displaced) &optional indexers params) ¶vacomp-scan) &optional indexers params) ¶Scan a function across an array along a given axis. Used to implement the [\ scan] operator with an option for inversion when used with the [⍣ power] operator taking a negative right operand.
vacomp-reduce) &optional indexers params) ¶Reduce an array along by a given function along a given dimension, optionally with a window interval.
vader-subarray-reduce) &optional indexers params) ¶vacomp-each) &optional indexers params) ¶vader-select) &optional indexers params) ¶vader-calculate) &optional indexers params) ¶vader-identity) &optional indexers params) ¶vader-decode) &optional indexers params) ¶vader-encode) &optional indexers params) ¶vader-matrix-divide) &optional indexers params) ¶vader-matrix-inverse) &optional indexers params) ¶vader-grade) &optional indexers params) ¶vader-permute) &optional indexers params) ¶vader-turn) &optional indexers params) ¶vader-union) &optional indexers params) ¶vader-unique) &optional indexers params) ¶vader-intersection) &optional indexers params) ¶vader-pick) &optional indexers params) ¶vader-expand) &optional indexers params) ¶vader-partition) &optional indexers params) ¶vader-enclose) &optional indexers params) ¶vader-section) &optional indexers params) ¶vader-split) &optional indexers params) ¶vader-subarray-split) &optional indexers params) ¶vader-catenate) &optional indexers params) ¶vader-interval-index) &optional indexers params) ¶vader-where) &optional indexers params) ¶vader-find) &optional indexers params) ¶vader-membership) &optional indexers params) ¶vader-enlist) &optional indexers params) ¶vader-compare) &optional indexers params) ¶vader-first-dim) &optional indexers params) ¶Index a reshaped array.
vader-depth) &optional indexers params) ¶Index an array depth value.
vader-reshape) &optional indexers params) ¶vader-shape) &optional indexers params) ¶Index a reshaped array.
vader-index) &optional indexers params) ¶vader-inverse-where) &optional indexers params) ¶vader-umask) &optional indexers params) ¶vader-without) &optional indexers params) ¶vader-deal) &optional indexers params) ¶vader-random) &optional indexers params) ¶vader-subarray) &optional indexers params) ¶vapri-axis-vector) &optional indexers params) ¶vapri-onehot-vector) &optional indexers params) ¶Return one if the index matches, zero if not.
vapri-coordinate-identity) &optional indexers params) ¶Each index returns a coordinate vector.
vapri-coordinate-vector) &optional indexers params) ¶vapri-apro-vector) &optional indexers params) ¶varray-derived) &optional indexers params) ¶If a derived virtual array has content assigned, its generator will simply derive from that assigned content; otherwise the specific generator for the virtual array will be returned.
array) &optional indexers params) ¶→ _typespec_
*Arguments and Values:*
_input_—an _input_.
_typespec_—a _type specifier_.
*Description:*
{input-element-type} returns a _type specifier_ that designates the _type_ of the elements in _input_.
index-stream)) ¶index-vector)) ¶→ _empty-p_
*Arguments and Values:*
_input_—an _input_.
_empty-p_—a _generalized boolean_.
*Description:*
{input-empty-p} returns _true_ if _input_ is empty.
index-stream)) ¶index-vector)) ¶index-list)) ¶→ _element_
*Arguments and Values:*
_input_—a non-empty _input_.
_element_—an _object_ of the _type_ designated by the _type specifier_
returned by {input-element-type} when called on _input_.
*Description:*
{input-first} returns the first element in _input_.
*Exceptional Situations:*
If _input_ is empty the behavior of {input-first} is unspecified.
index-stream)) ¶index-simple-string)) ¶index-simple-vector)) ¶index-vector)) ¶index-list)) ¶→ _position_
*Arguments and Values:*
_input_—an _input_.
_position_—an _integer_ between 0 and {array-dimension-limit} inclusively.
*Description:*
{input-position} returns the _position_ of _input_.
→ _rest_
*Arguments and Values:*
_input_—a non-empty _input_.
_rest_—the remaining _input_.
*Description:*
{input-rest} returns the remaining _input_ without the first element.
*Exceptional Situations:*
If _input_ is empty the behavior of {input-rest} is unspecified.
index-stream)) ¶index-simple-string)) ¶index-simple-vector)) ¶index-vector)) ¶index-list)) ¶→ _sequence_
*Arguments and Values:*
_input_—an _input_.
_length_—an _integer_ between 0 and {array-dimension-limit} inclusively.
_sequence_—a _sequence_.
*Description:*
{input-sequence} returns a _sequence_ of the next _length_ elements in
_input_.
*Exceptional Situations:*
If the number of elements in _input_ are less than _length_ the behavior of {input-sequence} is unspecified.
index-stream) (length integer)) ¶index-vector) (length integer)) ¶index-list) (length integer)) ¶integer)) ¶Invert an [⍳ index] function, returning the right argument passed to ⍳.
vapri-apro-vector) index-origin) ¶vader-identity) index-origin) ¶varray-derived) index-origin) ¶*Arguments and Values:*
_input-source_—an _object_.
*Description:*
{make-input} returns an _input_ for _input-source_.
Get the rank of an array.
Get the shape of an array.
vacomp-stencil)) ¶vacomp-produce)) ¶vacomp-scan)) ¶vacomp-reduce)) ¶vacomp-each)) ¶vader-select)) ¶vader-calculate)) ¶vader-identity)) ¶vader-decode)) ¶vader-encode)) ¶vader-matrix-divide)) ¶vader-matrix-inverse)) ¶vader-grade)) ¶vader-permute)) ¶vader-union)) ¶vader-unique)) ¶vader-intersection)) ¶vader-pick)) ¶vader-expand)) ¶The shape of an expanded or compressed array.
vader-partition)) ¶vader-enclose)) ¶vader-section)) ¶The shape of a sectioned array is the parameters (if not inverse, as for [↑ take]) or the difference between the parameters and the shape of the original array (if inverse, as for [↓ drop]).
vader-split)) ¶vader-catenate)) ¶vader-pare)) ¶The shape of a reshaped array is simply its argument.
vader-interval-index)) ¶vader-where)) ¶vader-enlist)) ¶vader-compare)) ¶The shape of a comparison result is always nil.
vader-first-dim)) ¶The shape of a reshaped array is simply its argument.
vader-depth)) ¶The shape of a reshaped array is simply its argument.
vader-reshape)) ¶The shape of a reshaped array is simply its argument.
vader-shape)) ¶The shape of a reshaped array is simply its argument.
vader-index)) ¶vader-inverse-where)) ¶vader-umask)) ¶vader-without)) ¶vader-deal)) ¶vader-random)) ¶vapri-axis-vector)) ¶vapri-onehot-vector)) ¶The vector’s shape is explicit.
vapri-coordinate-identity)) ¶Shape is explicit; dimensional factors are generated by this function if not set.
vapri-coordinate-vector)) ¶vapri-apro-vector)) ¶varray-derived)) ¶The default shape of a derived array is the same as the original array.
varray-derived)) ¶Extend derived arrays’ shape-of methods to collect data on array shape over the course of an array transformation.
varray)) ¶Virtual array shapes are referenced using the (varray-shape) method.
array)) ¶Literal array shapes are given by (array-dimensions).
Non-arrays have a nil shape.
Get the size of an array.
va-class) &rest params) ¶Extend allocation logic for all virtual array classes. This function acts as an interface to the extend-allocator functions (mostly found in combinatorics.lisp) which provide for special allocation behavior of virtual array classes; specifically the potential for their allocation to return a modified form of the base object rather than an instance of their actual class.
vader-identity) &key) ¶Condense successive right and left identities (like ⊢⊣3 4⍴⍳9) into a single identity with the deferred rendering metadata flag activated. Successive right identities (like ⊢⊢3 4⍴⍳9) will force rendering.
vader-turn) &key) ¶Sum cumulative rotations into a single rotation; currently only works with a scalar left argument.
varray-derived) &key) ¶If the instance’s base slot is already bound, it has been populated through one of he above type combinatorics and so should be returned with no changes.
Generic index.
structure-object.
common-lisp.
maxpc.input.index:index-position
0
This slot is read-only.
An each-composed array as with the [¨ each] operator.
A produce-composed array as with the [. inner/outer product] operator.
A reduce-composed array as with the [/ reduce] operator.
Whether the array measures only one unit along the axis to be reduced.
:unitary
A scan-composed array as with the [\ scan] operator.
A stencil-composed array as with the [⌺ stencil] operator.
generator-of.
prototype-of.
shape-of.
(setf vacst-base-dims).
vacst-base-dims.
(setf vacst-in-factors).
vacst-in-factors.
(setf vacst-movement).
vacst-movement.
(setf vacst-out-factors).
vacst-out-factors.
(setf vacst-win-dims).
vacst-win-dims.
(setf vacst-win-factors).
vacst-win-factors.
(setf vacst-win-offsets).
vacst-win-offsets.
Vector of base array’s dimensions.
:base-dims
Dimensions for windows within stencil.
:win-dims
Space offsets for windows within stencil.
:win-offsets
Dimensional factors for stencil window.
:win-factors
Stencil’s movement parameters.
:movement
Dimensional factors for stencil input.
:in-factors
Dimensional factors for stencil output.
:out-factors
Parameters for scalar operation to be performed.
:params
Function to be applied to derived array element(s).
:function
Shape of a lower-rank array to be combined with a higher-rank array along given axes.
:sub-shape
A catenated array as from the [, catenate] function.
Whether this catenation laminates arrays.
:laminating
The first dimension of an array as from the [≢ first dimension] function.
An array produced by an operator-composed function.
Left function composed with operator.
:left
Right function composed with operator.
:right
Right argument to composed function.
:omega
Left argument to composed function.
:alpha
Whether this operation is asynchronous; i.e. operand functions lack side effects.
t
:async
A shuffled index vector as from the [? deal] function.
Cached shuffled vector elements.
:cached
A decoded array as from the [⊥ decode] function.
The first dimension of an array as from the [≢ first dimension] function.
An enclosed or re-enclosed array as from the [⊂ enclose] function.
Inner shape value for re-enclosed array.
:inner-shape
An encoded array as from the [⊤ encode] function.
An array decomposed into a vector as from the [∊ enlist] function.
An expanded (as from [ expand]) or compressed (as from [/ compress]) array.
Whether this section separates sections of the input with empty space in between to be filled with the array’s prototype.
:separating
An array of search matches as from the [⍷ find] function.
The first dimension of an array as from the [≢ first dimension] function.
A graded array as from the [⍋⍒ grade up/down] functions.
The identity of an array as from the [⊢ identity] function.
An indexed array as from the [⍳ index of] function.
An array intersection as from the [∩ intersection] function.
Interval indices of value(s) as from the [⍸ interval index] function.
An inverted product of the [⍸ where] function.
A matrix-divided array as from the [⌹ matrix divide] function.
A matrix-inverse array as from the [⌹ matrix inverse] function.
A membership array as from the [∊ membership] function.
Set of elements to be checked for membership in array.
:to-search
A mixed array as from the [↑ mix] function.
An array with a reduced shape as from the [, catenate] or [⍪ table] functions.
A partitioned array as from the [⊆ partition] function.
Parameters for partitioning.
:params
A permuted array as from the [⍉ permute] function.
Whether this permutation is diagonal, as from 1 1 2⍉2 3 4⍴⍳9.
:is-diagonal
An element from within an array as from the [⊃ disclose] or [⊃ pick] functions.
Reference to the array designated by this function.
:reference
Item to be assigned to selected index in array.
:assign
Virtual array selecting items within index to assign.
:selector
Function to be applied to selected index in array.
:assign
Index for assignment path.
0
:assign-path-index
An array of randomized elements as from the [? random] function.
A reshaped array as from the [⍴ reshape] function.
A sectioned array as from the [↑ take] or [↓ drop] functions.
Item(s) to be assigned to selected indices in array.
:assign
Function to select items to be assigned as for ⌽@(<∘5)⊢⍳9.
:assign-if
Shape of area to be assigned, eliding 1-sized dimensions.
:assign-shape
Function to be called on original and assigned index values.
:calling
Object implementing selection function for array.
:selector
The shape of an array as from the [⍴ shape] function.
A split array as from the [↓ split] function.
Subarray of a larger array; its relationship to the larger array is defined by its index parameter, indexer and prototype functions.
Index variable for subarray; often used to index the subarray as part of the larger array it derives from.
:index
An element of a split array as from the [↓ split] function.
A rotated array as from the [⌽ rotate] function.
Real degrees to rotate the array (with modulo applied).
:degrees
The unique mask of an array as from the [≠ unique mask] function.
An array intersection as from the [∩ union] function.
An array intersection as from the [∩ intersection] function.
Parameters for partitioning.
:indices
The coordinates of array elements equal to 1 as from the [⍸ where] function.
An array without given elements as from the [~ without] function.
Arithmetic progression vector - a series of numeric values generated by [⍳ index].
The number of values.
1
:number
The origin point - by default, the index origin.
0
:origin
The offset - an amount added to or subtracted from each value.
0
:offset
Factor of values.
1
:factor
Instances of each value.
1
:repeat
Coordinate identity array - an array of coordinate vectors generated by [⍳ index].
The shape of the array.
1
:number
One-hot vector - a binary vector where one element is set to 1.
The index equal to one.
0
:index
Virtual array - the ancestor class for all virtual array objects.
The array’s shape - typically populated by a (shape-of) method.
:shape
The array’s generator - typically populated by a (generator-of) method.
:generator
The array’s prototype - typically populated by a (prototype-of) method.
:prototype
Metadata for the array.
:meta
Call an APL function with one or two arguments. Compose successive scalar functions into bigger functions for more efficiency.
A wrapper macro for macros that implement April’s operators; functionally this macro does nothing but it improves the readability of April’s compiled code.
Generate code to output the result of APL evaluation, with options to print an APL-formatted text string expressing said result and/or return the text string as a result.
This is macro is used to build variable assignment forms and includes logic for strand assignment.
Wrap a function form in a function that calls it via (a-call). Used for specification of inverse scalar functions.
Wrapper for the choose function.
Generate a lambda with a self-reference for use with APL’s ∇ character for self-reference in a defn.
Generate a function aliasing a lexical function which may be monadic or dyadic; an ambivalent reference.
Wrap a glyph referencing a lexical function, and if more parameters are passed, use them as a list of implicit args for the primary function represented by that glyph, the resulting secondary function to be called on the argumants passed in the APL code.
Wrap a glyph referencing a scalar lexical function, with axes handled appropriately and defaulting to the (apl-fn) handling of .
Expands to an APL-style if-statement where clauses are evaluated depending on whether given expressions evaluate to 1 or 0.
This macro aliases (progn) - it is a solution for macros like (iterate) that chew up (progns) found in April’s generated code.
Specify the lexicon for a function - this means wrapping the function’s contents in a (let) form referencing external variables as appropriate.
Wrap a function in another function so that it may carry metadata.
Evaluates one form if the initial clause evaluates to a function, the other if it’s a variable. Used to implement ⍺←function cases within defns, most often ⍺←⊢.
Macro that interns symbols in the current workspace; works in tandem with ⊏ reader macro.
Macro used in grammar.lisp to intern value-referencing symbols in appropriate workspace package.
Wrap a function to be inverted; returns an error if the function has no inverse form.
Checks if a variable is present in the current workspace as a function.
Checks if a variable is present in the current workspace as an operator.
Checks if a variable is present in the current workspace as a value.
Wrapper for the choose function.
Macro to expedite the fetching of values from nested namespaces.
Generate a lambda with a self-reference for use with APL’s ∇∇ symbol for self-reference in a defined operator.
Wrap a lexical function; this is needed to implement some meta-functionality.
Print a formatted code string and then run the code; used in april’s arbitrary evaluation tests.
Run the tests for each April library package.
Wrap a scalar function. This is a passthrough macro used by the scalar composition system in (a-call).
This macro is used to specify a set of information and tests for an April demo package, currently used for some of those found in the /demos folder.
Assign array metadata appropriately to arrays resulting from scalar operations along with newly assigned arrays. Currently this is used to migrate array prototypes, as for operations like 1+0↑⊂3 3⍴⍳9.
Process the specification for a vector language and build functions that generate the code tree.
Wraps with-open-file forms, designates the format for Vex-compatible input files as UTF-8.
Curry a function with axes for use with an operator.
Parse a string of text, converting its contents into nested lists of Vex tokens.
Add a line loading the ApREPL utility to the Emacs init file so ApREPL will be ready for use when Emacs is loaded.
Adjust axes passed to a function to account for the given index origin.
Returns the default element for an array based on that array’s first element (its prototype in array programming terms); blank spaces in the case of a character prototype and zeroes for others.
Find a number’s ceiling deriving from the complex floor algorithm if needed.
Generate a division function according to the [⎕DIV division method] in use.
Power of e function that will always output a double-precision float as per APL standard.
Exponent function that will always output a double-precision float except if both arguments are integers, as per APL standard.
Find a number’s floor using the complex floor algorithm if needed.
Implementation of greatest common denominator extended to complex numbers based on the complex-floor function.
Implementation of lease common multiple extended to complex numbers based on the complex-floor function.
Logarithm function that will always output a double-precision float as per APL standard.
Randomize an array or scalar value. This must run synchronously over arrays without threading so that the same seed will produce the same output. Used to implement [? random].
Core of (apl-random), randomizing an individual integer or float.
Core of (apl-random), randomizing an individual integer or float.
Implementation of residue extended to complex numbers based on the complex-floor function.
Generate an APL timestamp, a vector of the current year, month, day, hour, minute, second and millisecond.
Return a function to find the greatest common denominator or least common multiple of fractional as well as whole numbers. If one or both arguments are floats, the result is coerced to a double float.
Sets one or more metadata of an array using the displacement reference technique, returning the displaced array.
Convert an array to a nested vector. Useful for applications such as JSON conversion where multidimensional arrays must be converted to nested vectors.
Assign to elements of an array selected by a function. Used to implement (3↑x)←5 etc.
Find the value(s) at the given index or indices in an array. Used to implement [⌷ index].
Get or set values within a namespace (structured as a ptree), handling arrays within the namespace according to array indices within the namespace path or eliding arrays in the absence of specific coordinates.
This function returns an APL vector; in the case of virtual arrays within the vector, a nested virtual container vector is returned.
Take a list of axes and assign the derived row-major indices to a vector with a fill point.
Flip a binary value. Used to implement [~ not].
Construct a set of axes from an (:axes) token form.
Format a function to be called within generated APL code.
Return a set of compiled April expressions within the proper context.
Construct an APL function; this may be a simple lexical function like +, an operator-composed function like +.× or a defn like {⍵+5}.
Build an operator like @ (a lexical operator), {⍺⍺/⍵} (a defined operator) or an operator assignment like p←⍣.
Generate a function that will populate array elements with an empty array prototype.
Build a documentation or test profile from a set of section names in a Vex idiom specification.
Construct an APL value; this may be a scalar value like 5, a vector like 1 2 3, or the result of a function lilike 1+2.
Create the set of variable declarations that begins April’s compiled code.
Utility macro function for %HANDLER-CASE and %RESTART-CASE.
Change the current ’namespace point’ within the workspace. Used to implement ⎕CS.
This (acos) implementation is used for ECL, whose stock (acos) is different from other CLs.
Create an array with a numerically designated type holding the contents of the given array. Used to implement ⎕TY.
Generate a comparison function using the [⎕CT comparison tolerance].
Compile a series of APL expressions.
Complete the composition of a branch statement, either creating or optionally moving to a branch within an APL expression.
Exension of (build-value) and (build-function) to process functions composed with pivotal operators.
Complete the compilation of a value assignment; wraps the (compose-value-assignment) function.
Find the floor of a complex number using Eugene McDonnell’s algorithm.
Compose a function assignment.
Compose a function using a lateral operator like [/ reduce].
Compose a function using a pivotal operator like [⍣ power].
Compose a function train like (-,÷).
Compose a value assignment like v←1 2 3.
Count the available threads in the system, accounting for different operating systems.
Count occurrences of a symbol in the spec. Used to plan the number of Prove tests to run.
Implementation of APL’s [⍳ index] function.
Extract a list of function/operator glyphs from part of a Vex language specification.
If the argument is a non-nested array with only one member, disclose it, otherwise do nothing.
Placeholder function to be assigned to newly initialized function symbols.
Placeholder function to be assigned to newly initialized operator symbols.
Apply axes to an array, with the ability to handle multiple sets of axes as in (6 8 5⍴⍳9)[1 4;;2 1][1;2 4 5;].
Extend allocation behavior of operate class; currently, this allows for things like 1+⍳9 returning a modified integer progression vector rather than an instance of the vader-calculate class.
Extend allocation behavior of expand class; allows for 3/⍳3 to produce a repeating integer progression vector instead of a vader-expand instance.
Extend allocation behavior of inverse-where class; allows the use of ⍸⍣¯1 to create one-hot vectors.
Extend allocation behavior of permute class; allows simple inversion of permutation without an argument.
Extend allocation behavior of section class; allows resizing of one-hot vectors.
Import a function from an external workspace, implementing the ⎕XWF function.
Import an operator from an external workspace, implementing the ⎕XWO function.
Import a value from an external workspace, implementing the ⎕XWV function.
Given a list of tokens starting with axis specifications, build the code for the axis specifications to be applied to the subsequent function or value.
Fast version of iota-sum for integers of type fast-iota-sum-fixnum
If a value build produces a pivotal function composition, it is built as a function. Needed for cases like fn←{2+⍵}⍣3 ⋄ fn 5.
Follow a path through a namespace and fetch the function or value there.
Use (aplesque:array-impress) to print an array and return the resulting character array, with the option of specifying decimal precision. Used to implement monadic and dyadic [⍕ format].
Generate a function using (aplesque:array-impress) to print an array in matrix form without collation. Used to implement ⎕FMT.
Create a string representation of a namespace path from the symbol list implementing that path.
Convert a token string into an APL value, paying heed to APL’s native ⍺, ⍵ and ⍬ variables.
Gamma function using Lanczos approximation.
Given an array, generate an array of the same shape whose each cell contains its row-major index.
Gets one or more metadata of an array using the displacement reference technique.
Find a list of symbols within a token list which are assigned with the [← gets] lexical function. Used to find lists of variables to hoist in lambda forms.
Get the set of dimensional factors corresponding to a set of array dimensions.
Find the number of threads currently available in the system.
Find a binomial for integer parameters.
Indent a code string produced by (print-and-run) as appropriate for April’s test output.
Return indices of an array expanded as with the [/ compress] or [\ expand] functions.
Return indices of an array permuted as with the [⍉ permute] function.
Return indices of an array permuted as with the [⍉ permute] function.
Return indices of an array sectioned as with the [↑ take] or [↓ drop] functions.
Return indices of an array sectioned as with the [↑ take] or [↓ drop] functions.
Return indices of an array rotated as with the [⌽ rotate] or [⊖ rotate first] functions.
Return indices of an array rotated as with the [⌽ rotate] or [⊖ rotate first] functions.
Generate the inverted deferred computation object that serves to verify indices in a selection array implementing assignment by selection, like the one expressed by {na←3⍴⊂⍳4 ⋄ (1↑⊃na[1])←⍵ ⋄ na} 99.
Invert a function expression. For use with the [⍣ power] operator taking a negative right operand.
Fast implementation of +/⍳X.
Consistently check whether a character is alphanumeric - needed since different CL implementations consider different sets of characters to be alphanumeric as per (alphanumericp).
Recursive factorial-computing function. Based on P. Luschny’s code.
Process the output of the lexer, assigning values in the workspace and closure metadata as appropriate. Mainly used to process symbols naming functions and variables.
Create or update a playfield for Conway’s Game of Life.
Linear regression for coefficient matrix ⍵ and constants ⍺. Used to implement dyadic [⌹ matrix divide] for an overspecified system
Load the April library packages.
Create a namespace. Used to implement ⎕NS. A namespace is just a plist, so this returns nil.
Make a prototype version of an array; all values in the array will be blank spaces for character arrays or zeroes for other types of arrays.
Create a kernel for multithreaded executuion via lparallel if none is present.
Divide two matrices. Used to implement dyadic [⌹ matrix divide].
Merge options from multiple Vex specifiction sections into a single set.
Determing if a number is close enough to an integer to be treated as such.
Determine if the number is ’real enough’ to be treated as such.
Fetch a combined list of symbols of a given type at each level of a closure metadata hierarchy. Used to query data collected as part of lexer postprocessing.
Generate a function applying a function at indices in an array specified by a given index or meeting certain conditions. Used to implement [@ at].
Generate a function applying a function to sub-arrays of the arguments. Used to implement [⍤ rank].
Generate a function applying two functions to a value in succession. Used to implement [⍤ atop].
Generate a function by linking together two functions with the left one called first. Used to implement [⍛ reverse compose].
Generate a function by linking together two functions or a function curried with an argument. Used to implement [∘ compose].
Generate a function with reversed or mirrored arguments. Used to implement [⍨ commute].
Generate a function applying a function to items grouped by a criterion. Used to implement [⌸ key].
Generate a function producing an outer product. Used to implement [∘. outer product].
Generate a function applying a function via (aplesque:stencil) to an array. Used to implement [⌺ stencil].
Generate a function applying a function to a value and successively to the results of prior iterations a given number of times. Used to implement [⍣ power].
Express an APL inline function like {⍵+5}.
Express an APL value in the form of an explicit array specification or a symbol representing an array, supporting axis arguments.
Parse an APL numeric string into a Lisp value, handling high minus signs, J-notation for complex numbers and R-notation for rational numbers.
Parses line position of POSITION in INPUT.
Format a number as appropriate for APL, using high minus signs and J-notation for complex numbers, optionally at a given precision and post-decimal length for floats.
Process arbitrary tests within a spec containing expressions that are evaluated without being wrapped in an (april ...) form.
Process a set of function and operator specs, generating lists of their referring characters, recording counts of functions and operators and building their assignment forms.
Process a function token.
Process specs for general tests not associated with a specific function or operator.
Process a set of tests for Vex functions or operators.
Process a namespace for output, rendering all virtual arrays within.
Process an operator token.
Process items in a vector to be generated by the compiler, wrapping any array references in aplSymbol so that they are disclosed. This does not apply if the output vector is unitary (length 1).
Generate appropriate code to fetch or change elements nested within (arrays of) namespaces.
Process a value token.
Add a reference to a side effect to a closure metadata object.
Add a reference to a call to a symbolic function to a closure metadata object.
Return a function form if it’s valid as a function within compiled April code.
Generate an (nspath) namespace path form depending on the symbols found and the status of the workspace’s namespace point, set using ⎕CS.
Convert row-major [index] into a list of the corresponding array coordinates according to [dims] dimensions of array.
Derive an array’s row-major index from a vector of subscripts.
This is a port of SBCL’s (rationalize) function. It is needed for use in ABCL and ECL, whose (rationalize) implementations appear to simply pass through to (rational).
Convert Unicode characters into integers and vice versa. Used to implement ⎕UCS.
Compare two scalar values as appropriate for APL.
Create a vector of lengths and start points for segments of a vector to be processed in parallel.
Sets one or more metadata of an array using the displacement reference technique.
Set the namespace point to be used by the compiler; this point is prepended to all symbols or namespace segments.
Use a function’s metadata to check whether it has side effects. Needed for multithreaded operators - the functions composed with operators must be free of side effects for multithreading.
Use a function’s metadata to check whether it has side effects. Needed for multithreaded operators - the functions composed with operators must be free of side effects for multithreading.
Return true if the argument is an array whose elements are integers narrower than 7 bits.
Return the element size in bits if the argument is an array whose elements are integers smaller than 7 bits.
Check for the existence of a shell command under the host operating system.
Find the maximum depth of nested arrays within an array.
Compare two vectors by the values of each element, giving priority to elements proportional to their position in the array, as when comparing words by the alphabetical order of the letters.
Remove elements in omega from alpha. Used to implement dyadic [~ without].
vader-pick) base &optional path path-indexer path-index) ¶Compile a form effecting the conversion of the input array to the output array.
Get a function effecting a virtual array indexing method in code.
vader-expand) &optional params) ¶vader-permute) &optional params) ¶vader-turn) &optional params) ¶vader-section) &optional params) ¶vader-permute) &optional params) ¶vader-turn) &optional params) ¶vader-expand) &optional params) ¶vader-section) &optional params) ¶The base effector returns nil.
Fetch the array targeted by an invocation of [⊃ disclose] or [⊃ pick].
vader-pick) base &optional path path-index) ¶Get the result of an array reduced using a particular function.
vapri-apro-vector) function) ¶Get an indexing function for an array.
vader-expand) &optional params) ¶vader-section) &optional params) ¶Indexer for a sectioned array.
vader-reshape) &optional params) ¶Index a reshaped array.
array) &optional params) ¶The indexer for a non-array is its identity.
Get metadata of a virtual array.
Get the prototype of an array.
vader-stencil-margin)) ¶vader-stencil-window)) ¶vacomp-stencil)) ¶vader-subarray-displaced)) ¶vacomp-produce)) ¶vacomp-scan)) ¶vader-subarray-reduce)) ¶vacomp-reduce)) ¶vacomp-each)) ¶vader-calculate)) ¶vader-identity)) ¶vader-grade)) ¶vader-intersection)) ¶vader-pick)) ¶vader-enclose)) ¶vader-section)) ¶vader-subarray-split)) ¶vader-catenate)) ¶vader-interval-index)) ¶vader-where)) ¶Prototype is an array of zeroes with length equal to the base array’s rank.
vader-find)) ¶vader-compare)) ¶vader-first-dim)) ¶vader-depth)) ¶vader-reshape)) ¶vader-shape)) ¶vader-index)) ¶vader-inverse-where)) ¶vader-umask)) ¶vader-deal)) ¶vader-subarray)) ¶vapri-onehot-vector)) ¶Prototype is zero, of course.
vapri-coordinate-identity)) ¶Prototype is an array of zeroes with length equal to the array’s rank.
vapri-coordinate-vector)) ¶vapri-apro-vector)) ¶varray-derived)) ¶The prototype representation of an item is returned by the (apl-array-prototype) function.
Render a virtual array into memory.
vader-identity) &rest params) ¶A special non-rendering render method for [⊢/⊣ identity], to be used when ⊢⊣X is invoked to defer rendering.
Rendering a non-virtual array object simply returns the object.
Specify calculation methods for a virtual array’s transformation.
Get a sub-indexing function for an array.
vader-catenate)) ¶vader-catenate)) ¶Whether this catenation laminates arrays.
vader-composing)) ¶vader-composing)) ¶Left argument to composed function.
vader-composing)) ¶vader-composing)) ¶Whether this operation is asynchronous; i.e. operand functions lack side effects.
vader-composing)) ¶vader-composing)) ¶Left function composed with operator.
vader-composing)) ¶vader-composing)) ¶Right argument to composed function.
vader-composing)) ¶vader-composing)) ¶Right function composed with operator.
vapri-coordinate-vector)) ¶vapri-coordinate-vector)) ¶The row-major index of the referenced array this coordinate vector represents.
vapri-coordinate-vector)) ¶vapri-coordinate-vector)) ¶The array to which this coordinate vector belongs.
vacomp-reduce)) ¶vacomp-reduce)) ¶Whether the array measures only one unit along the axis to be reduced.
vacomp-stencil)) ¶vacomp-stencil)) ¶Vector of base array’s dimensions.
vacomp-stencil)) ¶vacomp-stencil)) ¶Dimensional factors for stencil input.
vacomp-stencil)) ¶vacomp-stencil)) ¶Stencil’s movement parameters.
vacomp-stencil)) ¶vacomp-stencil)) ¶Dimensional factors for stencil output.
vacomp-stencil)) ¶vacomp-stencil)) ¶Dimensions for windows within stencil.
vacomp-stencil)) ¶vacomp-stencil)) ¶Dimensional factors for stencil window.
vacomp-stencil)) ¶vacomp-stencil)) ¶Space offsets for windows within stencil.
vader-deal)) ¶vader-deal)) ¶Cached shuffled vector elements.
varray-derived)) ¶varray-derived)) ¶The array from which the array is derived.
varray-derived)) ¶varray-derived)) ¶Cached rendered content of the array.
varray-derived)) ¶varray-derived)) ¶The number of derived virtual arrays downstream of this array.
vader-expand)) ¶vader-expand)) ¶Whether this section separates sections of the input with empty space in between to be filled with the array’s prototype.
vad-with-argument)) ¶vad-with-argument)) ¶Parameters passed to an array transformation as an argument.
vad-on-axis)) ¶vad-on-axis)) ¶The axis along which to transform.
vad-with-ct)) ¶vad-with-ct)) ¶Parameter specifying the comparison tolerance for an array operation.
vad-with-default-axis)) ¶vad-with-default-axis)) ¶The default axis along which to transform.
vad-with-dfactors)) ¶vad-with-dfactors)) ¶Array’s dimensional factors.
vad-invertable)) ¶vad-invertable)) ¶Parameters passed to an array transformation as an argument.
vad-with-io)) ¶vad-with-io)) ¶Parameter specifying the index origin for an array operation.
varray-derived)) ¶varray-derived)) ¶Whether the array contains nested elements to be subrendered.
vad-nested)) ¶vad-nested)) ¶Whether the array contains nested elements to be subrendered.
vad-render-mutable)) ¶vad-render-mutable)) ¶Whether the array has been rendered.
vad-with-rng)) ¶vad-with-rng)) ¶Random number generator specification for array transformations that use it.
%rng.
vad-maybe-shapeless)) ¶vad-maybe-shapeless)) ¶Whether array’s shape is determined.
vader-enclose)) ¶vader-enclose)) ¶Inner shape value for re-enclosed array.
vader-find)) ¶vader-find)) ¶Cached data to search.
vader-find)) ¶vader-find)) ¶Pattern to find.
vader-index)) ¶vader-index)) ¶Cached items to search in array.
vader-index)) ¶vader-index)) ¶Cached items to search in array.
%set.
vader-membership)) ¶vader-membership)) ¶Set of elements to be checked for membership in array.
vapri-onehot-vector)) ¶vapri-onehot-vector)) ¶The index equal to one.
vader-calculate)) ¶vader-calculate)) ¶Function to be applied to derived array element(s).
vader-calculate)) ¶vader-calculate)) ¶Parameters for scalar operation to be performed.
vader-calculate)) ¶vader-calculate)) ¶Shape of a lower-rank array to be combined with a higher-rank array along given axes.
vader-partition)) ¶vader-partition)) ¶Parameters for partitioning.
vapri-coordinate-identity)) ¶vapri-coordinate-identity)) ¶The shape of the array.
vader-permute)) ¶vader-permute)) ¶Whether this permutation is diagonal, as from 1 1 2⍉2 3 4⍴⍳9.
vader-pick)) ¶vader-pick)) ¶Index for assignment path.
vader-pick)) ¶vader-pick)) ¶Item to be assigned to selected index in array.
vader-pick)) ¶vader-pick)) ¶Function to be applied to selected index in array.
vader-pick)) ¶vader-pick)) ¶Reference to the array designated by this function.
vader-pick)) ¶vader-pick)) ¶Virtual array selecting items within index to assign.
vapri-apro-vector)) ¶vapri-apro-vector)) ¶Factor of values.
vapri-apro-vector)) ¶vapri-apro-vector)) ¶The number of values.
vapri-apro-vector)) ¶vapri-apro-vector)) ¶The offset - an amount added to or subtracted from each value.
vapri-apro-vector)) ¶vapri-apro-vector)) ¶The origin point - by default, the index origin.
vapri-apro-vector)) ¶vapri-apro-vector)) ¶Instances of each value.
vader-subarray-reduce)) ¶vader-subarray-reduce)) ¶Delta for subarray to reduce.
vader-subarray-reduce)) ¶vader-subarray-reduce)) ¶Is subarray to be traversed in reverse order?.
vader-subarray-reduce)) ¶vader-subarray-reduce)) ¶Window length for subarray to reduce.
vader-subarray-split)) ¶vader-subarray-split)) ¶Core indexer for split subarray.
vader-section)) ¶vader-section)) ¶The number of prototype elements padding the output in each dimension.
%pad.
vader-section)) ¶vader-section)) ¶The start and end points of the section within the base array.
vader-select)) ¶vader-select)) ¶Item(s) to be assigned to selected indices in array.
vader-select)) ¶vader-select)) ¶Function to select items to be assigned as for ⌽@(<∘5)⊢⍳9.
vader-select)) ¶vader-select)) ¶Shape of area to be assigned, eliding 1-sized dimensions.
vader-select)) ¶vader-select)) ¶Function to be called on original and assigned index values.
vader-select)) ¶vader-select)) ¶Object implementing selection function for array.
vader-stencil-margin)) ¶vader-stencil-margin)) ¶Index of stencil margin vector.
vader-stencil-window)) ¶vader-stencil-window)) ¶Index of stencil window.
vader-subarray)) ¶vader-subarray)) ¶Index variable for subarray; often used to index the subarray as part of the larger array it derives from.
vader-turn)) ¶vader-turn)) ¶Real degrees to rotate the array (with modulo applied).
vader-unique)) ¶vader-unique)) ¶Parameters for partitioning.
vapri-axis-vector)) ¶vapri-axis-vector)) ¶The axis along which the axis vector leads.
vapri-axis-vector)) ¶vapri-axis-vector)) ¶This axis vector’s index within the reference array reduced along the axis.
vapri-axis-vector)) ¶vapri-axis-vector)) ¶The array to which this axis vector belongs.
vapri-axis-vector)) ¶vapri-axis-vector)) ¶The window of division along the axis.
Index list.
common-lisp.
list
(error "must supply list.")
This slot is read-only.
Index simple string.
Index simple vector.
Index vector.
common-lisp.
vector
(error "must supply vector.")
This slot is read-only.
Metaclass for virtual array objects.
standard-class.
Superclass of array transformations that have an inverse variant as [↓ drop] is to [↑ take].
Parameters passed to an array transformation as an argument.
:inverse
Superclass of indefinite array transformations whose output can be dimensionally limited to avoid needless computation.
Superclass of array transformations taking index origin as an implicit argument.
Whether array’s shape is determined.
:determined
Superclass of derived arrays containing sub-arrays to be rendered.
Whether the array contains nested elements to be subrendered.
t
:nested
Superclass of array transformations occuring along an axis.
The axis along which to transform.
:axis
Superclass of array transformations that add an index transformation to those accumulated.
Superclass of array transformations whose content may be changed in place upon rendering and whose rendered/non-rendered status must therefore be tracked.
Whether the array has been rendered.
:rendered
Superclass of array transformations occuring along an axis.
vader-catenate.
vader-deal.
vader-decode.
vader-enclose.
vader-encode.
vader-expand.
vader-find.
vader-grade.
vader-index.
vader-interval-index.
vader-inverse-where.
vader-matrix-divide.
vader-membership.
vader-partition.
vader-permute.
vader-pick.
vader-reshape.
vader-section.
vader-select.
vader-stencil-margin.
vader-turn.
vader-without.
Parameters passed to an array transformation as an argument.
:argument
Superclass of array transformations taking comparison tolerance as an implicit argument.
Parameter specifying the comparison tolerance for an array operation.
0
:comparison-tolerance
Superclass of array transformations with a default axis.
The default axis along which to transform.
:default-axis
Superclass of derived arrays with cached dimensional factors.
Array’s dimensional factors.
:dfactors
Superclass of array transformations taking index origin as an implicit argument.
vacomp-produce.
vacomp-reduce.
vacomp-scan.
vacomp-stencil.
vader-calculate.
vader-catenate.
vader-deal.
vader-enclose.
vader-expand.
vader-grade.
vader-index.
vader-interval-index.
vader-inverse-where.
vader-mix.
vader-pare.
vader-partition.
vader-permute.
vader-pick.
vader-random.
vader-section.
vader-select.
vader-split.
vader-turn.
vader-where.
vapri-axis-vector.
vapri-coordinate-identity.
Parameter specifying the index origin for an array operation.
0
:index-origin
Superclass of array transformations occuring along an axis.
Random number generator specification for array transformations that use it.
:rng
A stencil margin vector, enumerating the margin padding in a stencil window array produced by [⌺ stencil].
Index of stencil margin vector.
:index
A stencil window, part of a stencil array produced by [⌺ stencil].
Index of stencil window.
:index
A subarray created as part of a [/ reduce] operation.
Window length for subarray to reduce.
:window
Delta for subarray to reduce.
:delta
Is subarray to be traversed in reverse order?.
:reverse
An element of a split array as from the [↓ split] function.
Core indexer for split subarray.
:core-indexer
A sub-vector along an axis of an array.
The array to which this axis vector belongs.
:reference
The axis along which the axis vector leads.
:axis
The window of division along the axis.
:window
This axis vector’s index within the reference array reduced along the axis.
:index
Coordinate vector - a vector of the integer coordinates corresponding to a given row-major index in an array.
The array to which this coordinate vector belongs.
:reference
The row-major index of the referenced array this coordinate vector represents.
0
:index
A derived array: a virtual array derived from another array.
vader-calculate.
vader-catenate.
vader-compare.
vader-composing.
vader-deal.
vader-decode.
vader-depth.
vader-enclose.
vader-encode.
vader-enlist.
vader-expand.
vader-find.
vader-first-dim.
vader-grade.
vader-identity.
vader-index.
vader-intersection.
vader-interval-index.
vader-inverse-where.
vader-matrix-divide.
vader-matrix-inverse.
vader-membership.
vader-mix.
vader-partition.
vader-permute.
vader-pick.
vader-random.
vader-reshape.
vader-section.
vader-select.
vader-shape.
vader-split.
vader-stencil-margin.
vader-stencil-window.
vader-subarray.
vader-turn.
vader-umask.
vader-union.
vader-unique.
vader-where.
vader-without.
The array from which the array is derived.
:base
The number of derived virtual arrays downstream of this array.
0
:layer
Whether the array contains nested elements to be subrendered.
:nested
Cached rendered content of the array.
:content
A primal array: a virtual array defined wholly by its parameters, not derived from another array.
The largest integer that can be supplied to fast-iota-sum without causing a fixnum overflow
| Jump to: | %
(
=
?
A B C D E F G I J L M N O P R S T V W X Y Λ |
|---|
| Jump to: | %
(
=
?
A B C D E F G I J L M N O P R S T V W X Y Λ |
|---|
| Jump to: | %
*
∇
A B L N P S T U V |
|---|
| Jump to: | %
*
∇
A B L N P S T U V |
|---|
| Jump to: | A B C D E F G I L M N P S T U V |
|---|
| Jump to: | A B C D E F G I L M N P S T U V |
|---|