The veq Reference Manual

3.1.1 veq/veq.asd

Source

veq.asd.

Parent Component

veq (system).

ASDF Systems

veq.

---

3.1.2 veq/packages.lisp

Source

veq.asd.

Parent Component

veq (system).

Packages

veq.

---

3.1.3 veq/init.lisp

Dependency

packages.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• init-config (macro).
• vgetenv (function).

---

3.1.4 veq/config.lisp

Dependency

init.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• *eps* (special variable).
• d? (function).
• i? (function).
• v? (function).

Internals

• *dev* (special variable).
• *opt* (special variable).

---

3.1.5 veq/generic-utils.lisp

Dependency

config.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• dsb (macro).
• mac (macro).
• mac* (macro).
• mvb (macro).
• mvc (macro).

Internals

• -gensyms (function).
• abbrev (macro).
• aif (macro).
• at-most (function).
• awf (macro).
• awg (macro).
• dotted-listp (function).
• dupes (function).
• edge-fx (function).
• edge-str (function).
• flatten (function).
• fx-split-str (function).
• group (function).
• last* (function).
• lpos (function).
• lst>n (function).
• mapqt (function).
• match-substr (function).
• mkstr (function).
• nilpad (function).
• nth* (function).
• psymb (function).
• push* (macro).
• reread (function).
• split-string (function).
• split-substr (function).
• strcat (function).
• strip-symbols (function).
• symb (function).
• undup (function).
• with-gensyms (macro).
• with-struct (macro).

---

3.1.6 veq/types.lisp

Dependency

generic-utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• arrtype (function).
• df (function).
• df (type).
• df* (macro).
• dfl (function).
• dvec (type).
• ff (function).
• ff (type).
• ff* (macro).
• ffl (function).
• fvec (type).
• in (function).
• in (type).
• in* (macro).
• ivec (type).
• kv (function).
• kv (type).
• kv* (macro).
• kvec (type).
• ll (function).
• ll (type).
• ll* (macro).
• lvec (type).
• pn (function).
• pn (type).
• pn* (macro).
• pos-df (type).
• pos-ff (type).
• pvec (type).
• svec (type).
• sy (function).
• sy (type).
• sy* (macro).
• type-default (function).
• type-from-short (function).
• unpack-vvsym (function).
• vvsym (function).

---

3.1.7 veq/utils.lisp

Dependency

types.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• dpi (constant).
• dpi25 (constant).
• dpi5 (constant).
• dpii (constant).
• fpi (constant).
• fpi25 (constant).
• fpi5 (constant).
• fpii (constant).
• from-lst (macro).
• lst (macro).
• mvcgrp (macro).
• mvcmap (macro).
• vchain (macro).
• vnrep (macro).
• vnval (macro).
• vp (macro).
• vpr (macro).
• ~ (macro).

Internals

define-constants (macro).

---

3.1.8 veq/docs.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• context? (macro).
• ext-symbols? (macro).

Internals

• *docstring-map* (special variable).
• -md-sanitize (function).
• desc (function).
• docstrings (function).
• map-docstring (function).
• pckgs (macro).
• select-docs (function).

---

3.1.9 veq/vset.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• (setf $) (setf expander).
• $nvset (macro).
• (setf 2$) (setf expander).
• (setf 3$) (setf expander).
• (setf 4$) (setf expander).

Internals

make-$defsetf (macro).

---

3.1.10 veq/lets.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• vlabels (macro).
• xlet (macro).

Internals

• -vlet (function).
• -vlet* (function).
• -vmvb (function).
• -vmvb* (function).
• define-creators (macro).
• define-rep (macro).
• define-td (macro).
• define-td~ (macro).
• define-val (macro).
• define-vlet (macro).
• define-xlet-macro (macro).
• dim? (function).
• xlet-proc (function).

---

3.1.11 veq/macros-helpers.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

replace-varg (function).

Internals

• filter-macrolets (function).
• find-all-relevant-symbols (function).

---

3.1.12 veq/veq-ops.lisp

Dependency

macros-helpers.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• *errmsg* (special variable).
• *symbols-map* (special variable).
• -expand-!symb (function).
• -expand-and-flatten-!symbols (function).
• -placeholders (function).
• body-len (function).
• map-symbol (function).
• op (macro).
• ops (macro).
• optype (function).

---

3.1.13 veq/ops-1.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• -d^ (function).
• -dclamp (function).
• -dclamp* (function).
• -dcos-sin (function).
• -ddeg->rad (function).
• -dexp (function).
• -dfrom (function).
• -di- (function).
• -di/ (function).
• -did (function).
• -discale (function).
• -dlen (function).
• -dlen2 (function).
• -dlerp (function).
• -dmid (function).
• -dmod (function).
• -dscale (function).
• -dsin-cos (function).
• -dsqrt (function).
• -dsquare (function).
• -f^ (function).
• -fclamp (function).
• -fclamp* (function).
• -fcos-sin (function).
• -fdeg->rad (function).
• -fexp (function).
• -ffrom (function).
• -fi- (function).
• -fi/ (function).
• -fid (function).
• -fiscale (function).
• -flen (function).
• -flen2 (function).
• -flerp (function).
• -fmid (function).
• -fmod (function).
• -fscale (function).
• -fsin-cos (function).
• -fsqrt (function).
• -fsquare (function).

---

3.1.14 veq/ops-2.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• -d2^ (function).
• -d2angle (function).
• -d2cross (function).
• -d2dot (function).
• -d2dst (function).
• -d2dst2 (function).
• -d2exp (function).
• -d2flip (function).
• -d2from (function).
• -d2i- (function).
• -d2i/ (function).
• -d2id (function).
• -d2iscale (function).
• -d2len (function).
• -d2len2 (function).
• -d2lerp (function).
• -d2max (function).
• -d2mid (function).
• -d2min (function).
• -d2mod (function).
• -d2norm (function).
• -d2on-circ (function).
• -d2on-circ* (function).
• -d2perp (function).
• -d2perp* (function).
• -d2rot (function).
• -d2rots (function).
• -d2scale (function).
• -d2sqrt (function).
• -d2square (function).
• -f2^ (function).
• -f2angle (function).
• -f2cross (function).
• -f2dot (function).
• -f2dst (function).
• -f2dst2 (function).
• -f2exp (function).
• -f2flip (function).
• -f2from (function).
• -f2i- (function).
• -f2i/ (function).
• -f2id (function).
• -f2iscale (function).
• -f2len (function).
• -f2len2 (function).
• -f2lerp (function).
• -f2max (function).
• -f2mid (function).
• -f2min (function).
• -f2mod (function).
• -f2norm (function).
• -f2on-circ (function).
• -f2on-circ* (function).
• -f2perp (function).
• -f2perp* (function).
• -f2rot (function).
• -f2rots (function).
• -f2scale (function).
• -f2sqrt (function).
• -f2square (function).

---

3.1.15 veq/ops-3.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• -d3^ (function).
• -d3cross (function).
• -d3dot (function).
• -d3dst (function).
• -d3dst2 (function).
• -d3exp (function).
• -d3from (function).
• -d3i- (function).
• -d3i/ (function).
• -d3id (function).
• -d3iscale (function).
• -d3len (function).
• -d3len2 (function).
• -d3lerp (function).
• -d3max (function).
• -d3mid (function).
• -d3min (function).
• -d3mod (function).
• -d3norm (function).
• -d3rot (function).
• -d3rots (function).
• -d3scale (function).
• -d3sqrt (function).
• -d3square (function).
• -f3^ (function).
• -f3cross (function).
• -f3dot (function).
• -f3dst (function).
• -f3dst2 (function).
• -f3exp (function).
• -f3from (function).
• -f3i- (function).
• -f3i/ (function).
• -f3id (function).
• -f3iscale (function).
• -f3len (function).
• -f3len2 (function).
• -f3lerp (function).
• -f3max (function).
• -f3mid (function).
• -f3min (function).
• -f3mod (function).
• -f3norm (function).
• -f3rot (function).
• -f3rots (function).
• -f3scale (function).
• -f3sqrt (function).
• -f3square (function).

---

3.1.16 veq/ops-4.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• -d4^ (function).
• -d4dot (function).
• -d4dst (function).
• -d4dst2 (function).
• -d4exp (function).
• -d4from (function).
• -d4i- (function).
• -d4i/ (function).
• -d4id (function).
• -d4iscale (function).
• -d4len (function).
• -d4len2 (function).
• -d4lerp (function).
• -d4max (function).
• -d4mid (function).
• -d4min (function).
• -d4mod (function).
• -d4norm (function).
• -d4scale (function).
• -d4sqrt (function).
• -d4square (function).
• -f4^ (function).
• -f4dot (function).
• -f4dst (function).
• -f4dst2 (function).
• -f4exp (function).
• -f4from (function).
• -f4i- (function).
• -f4i/ (function).
• -f4id (function).
• -f4iscale (function).
• -f4len (function).
• -f4len2 (function).
• -f4lerp (function).
• -f4max (function).
• -f4mid (function).
• -f4min (function).
• -f4mod (function).
• -f4norm (function).
• -f4scale (function).
• -f4sqrt (function).
• -f4square (function).

---

3.1.17 veq/macrolets.lisp

Dependencies

• macros-helpers.lisp (file).
• veq-ops.lisp (file).
• ops-1.lisp (file).
• ops-2.lisp (file).
• ops-3.lisp (file).
• ops-4.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• def* (macro).
• fvdef (macro).
• fvdef* (macro).
• fvprogn (macro).
• vdef (macro).
• vdef* (macro).
• vprogn (macro).

Internals

• define-def* (macro).
• define-fvdef (macro).
• define-fvdef* (macro).
• define-fvprogn (macro).
• define-vdef (macro).
• define-vdef* (macro).
• define-vprogn (macro).
• get-docs (function).
• make-wrap-docs (function).

---

3.1.18 veq/ops-vv-helpers.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

• $row (function).
• *vv-!@* (special variable).
• *vv-%@* (special variable).
• *vv-.@* (special variable).
• *vv-?@* (special variable).
• *vv-_@* (special variable).
• *vv-arr* (special variable).
• *vv-bang* (special variable).
• *vv-dot* (special variable).
• *vv-f@* (special variable).
• *vv-m@* (special variable).
• *vv-r@* (special variable).
• *vv-special* (special variable).
• *vv-x@* (special variable).
• ?@-index-type (function).
• ?@-loop-type (function).
• car-match-modifier (function).
• fx-strip (function).
• gk (function).
• gk+ (function).
• gk0 (function).
• lconf (function).
• niloutconf (function).
• nvrs (function).
• rconf (function).
• tailconf (function).
• vec-select-itr (function).
• vvconf (function).
• vverr (function).

---

3.1.19 veq/ops-vv.lisp

Dependency

ops-vv-helpers.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

vv (macro).

Internals

• define-vv-macro (macro).
• fx@conf (function).
• proc!@$fx (function).
• proc!@$fx$ (function).
• proc!@$fx. (function).
• proc!@.fx (function).
• proc!@fx (function).
• proc!@fx. (function).
• proc%@$fx (function).
• proc%@fx (function).
• proc.@$fx (function).
• proc.@fx (function).
• proc_@$fx (function).
• proc_@$fx. (function).
• proc_@fx (function).
• procf@fx (function).
• procm@fx (function).
• procr@$fx (function).
• procx@$fx (function).
• vv-proc (function).
• vverr-len (macro).

---

3.1.20 veq/array-utils.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• $make (macro).
• $num (function).
• 2$num (function).
• 3$num (function).
• 4$num (function).
• d$ (macro).
• d$_ (function).
• d$copy (function).
• d$make (macro).
• d$num (function).
• d$one (function).
• d$val (function).
• d$zero (function).
• d$~ (macro).
• d2$ (macro).
• d2$num (function).
• d2$one (function).
• d2$val (function).
• d2$zero (function).
• d3$ (macro).
• d3$num (function).
• d3$one (function).
• d3$val (function).
• d3$zero (function).
• d4$ (macro).
• d4$num (function).
• d4$one (function).
• d4$val (function).
• d4$zero (function).
• d_ (macro).
• f$ (macro).
• f$_ (function).
• f$copy (function).
• f$make (macro).
• f$num (function).
• f$one (function).
• f$val (function).
• f$zero (function).
• f$~ (macro).
• f2$ (macro).
• f2$num (function).
• f2$one (function).
• f2$val (function).
• f2$zero (function).
• f3$ (macro).
• f3$num (function).
• f3$one (function).
• f3$val (function).
• f3$zero (function).
• f4$ (macro).
• f4$num (function).
• f4$one (function).
• f4$val (function).
• f4$zero (function).
• f_ (macro).
• i$ (macro).
• i$_ (function).
• i$copy (function).
• i$make (macro).
• i$num (function).
• i$one (function).
• i$val (function).
• i$zero (function).
• i$~ (macro).
• i2$ (macro).
• i2$num (function).
• i2$one (function).
• i2$val (function).
• i2$zero (function).
• i3$ (macro).
• i3$num (function).
• i3$one (function).
• i3$val (function).
• i3$zero (function).
• i4$ (macro).
• i4$num (function).
• i4$one (function).
• i4$val (function).
• i4$zero (function).
• i_ (macro).
• new-stride (macro).
• p$ (macro).
• p$_ (function).
• p$copy (function).
• p$make (macro).
• p$num (function).
• p$one (function).
• p$val (function).
• p$zero (function).
• p$~ (macro).
• p2$ (macro).
• p2$num (function).
• p2$one (function).
• p2$val (function).
• p2$zero (function).
• p3$ (macro).
• p3$num (function).
• p3$one (function).
• p3$val (function).
• p3$zero (function).
• p4$ (macro).
• p4$num (function).
• p4$one (function).
• p4$val (function).
• p4$zero (function).
• p_ (macro).

Internals

• -$ (macro).
• define-$ (macro).
• define-arr-num (macro).
• define-arr-util (macro).
• define-constr (macro).

---

3.1.21 veq/array-rows.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• d$last (function).
• d2$last (function).
• d3$last (function).
• d4$last (function).
• f$last (function).
• f2$last (function).
• f3$last (function).
• f4$last (function).

Internals

• -struct-fields (function).
• make-last (macro).
• struct-fields (macro).

---

3.1.22 veq/select-dim.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• dsel (macro).
• fsel (macro).
• isel (macro).
• psel (macro).
• vsel (macro).

Internals

define-vsel (macro).

---

3.1.23 veq/fxlspace.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• d$lspace (macro).
• d2$lspace (macro).
• d3$lspace (macro).
• d4$lspace (macro).
• f$lspace (macro).
• f2$lspace (macro).
• f3$lspace (macro).
• f4$lspace (macro).

Internals

• %d$lspace (function).
• %d2$lspace (function).
• %d3$lspace (function).
• %d4$lspace (function).
• %f$lspace (function).
• %f2$lspace (function).
• %f3$lspace (function).
• %f4$lspace (function).
• -fxlspace (function).
• -lspace (macro).
• -wrapnum (function).
• map-fxlspace (macro).

---

3.1.24 veq/mat.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• d2meye (function).
• d2mm (macro).
• d2mmt (macro).
• d2mrot (macro).
• d2mrot* (macro).
• d2mscale (macro).
• d2mt! (macro).
• d2mtm (macro).
• d2mtmt (macro).
• d2mtrans (macro).
• d2mtv (macro).
• d2mv (macro).
• d3meye (function).
• d3mm (macro).
• d3mmt (macro).
• d3mrot (macro).
• d3mrot* (macro).
• d3mscale (macro).
• d3mt! (macro).
• d3mtm (macro).
• d3mtmt (macro).
• d3mtrans (macro).
• d3mtv (macro).
• d3mv (macro).
• d4meye (function).
• d4mm (macro).
• d4mmt (macro).
• d4mt! (macro).
• d4mtm (macro).
• d4mtmt (macro).
• d4mtv (macro).
• d4mv (macro).
• f2meye (function).
• f2mm (macro).
• f2mmt (macro).
• f2mrot (macro).
• f2mrot* (macro).
• f2mscale (macro).
• f2mt! (macro).
• f2mtm (macro).
• f2mtmt (macro).
• f2mtrans (macro).
• f2mtv (macro).
• f2mv (macro).
• f3meye (function).
• f3mm (macro).
• f3mmt (macro).
• f3mrot (macro).
• f3mrot* (macro).
• f3mscale (macro).
• f3mt! (macro).
• f3mtm (macro).
• f3mtmt (macro).
• f3mtrans (macro).
• f3mtv (macro).
• f3mv (macro).
• f4meye (function).
• f4mm (macro).
• f4mmt (macro).
• f4mt! (macro).
• f4mtm (macro).
• f4mtmt (macro).
• f4mtv (macro).
• f4mv (macro).

Internals

• %d2mrot (function).
• %d2mrot* (function).
• %d2mscale (function).
• %d2mtrans (function).
• %d3mrot (function).
• %d3mrot* (function).
• %d3mscale (function).
• %d3mtrans (function).
• %f2mrot (function).
• %f2mrot* (function).
• %f2mscale (function).
• %f2mtrans (function).
• %f3mrot (function).
• %f3mrot* (function).
• %f3mscale (function).
• %f3mtrans (function).
• make-2mrot (macro).
• make-3mrot (macro).
• make-mat-all-mm (macro).
• make-mat-eye (macro).
• make-mat-mm (macro).
• make-mat-mv (macro).
• make-mat-scale (macro).
• make-mat-trans (macro).
• make-mat-transp (macro).

---

3.1.25 veq/mat-inv.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• d2minv (function).
• d3minv (function).
• d4minv (function).
• f2minv (function).
• f3minv (function).
• f4minv (function).

Internals

• make-2minv (macro).
• make-3minv (macro).
• make-4minv (macro).

---

3.1.26 veq/mat-cam.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• fmake-ortho-proj-matrix (macro).
• fmake-proj-matrix (macro).
• fmake-view-matrix (macro).

Internals

• %fmake-ortho-proj-matrix (function).
• %fmake-proj-matrix (function).
• %fmake-view-matrix (function).

---

3.1.27 veq/array-extra.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• $print (function).
• $to-list (function).
• 2$print (function).
• 2$to-list (function).
• 3$print (function).
• 3$to-list (function).
• 4$print (function).
• 4$to-list (function).
• d$mima (function).
• d2$mima (function).
• d3$mima (function).
• f$mima (function).
• f2$mima (function).
• f3$mima (function).

Internals

-xmima (macro).

---

3.1.28 veq/checks.lisp

Dependency

array-extra.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• f2in-bbox (macro).
• f2in-concave (macro).
• f2in-triangle (macro).
• f2lsegx (macro).
• f2segdst (macro).
• f2segx (macro).
• f3planex (macro).

Internals

• %f2in-bbox (function).
• %f2in-concave (function).
• %f2in-triangle (function).
• %f2lsegx (function).
• %f2segdst (function).
• %f2segx (function).
• %f3planex (function).
• -sorted-point-pairs (function).
• -sweep-line (function).
• array-fvec (type).

---

3.1.29 veq/shapes.lisp

Dependency

array-extra.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• d$line (macro).
• d$point (macro).
• d2$line (macro).
• d2$point (macro).
• d3$line (macro).
• d3$point (macro).
• d4$line (macro).
• d4$point (macro).
• f$line (macro).
• f$point (macro).
• f2$center (function).
• f2$circ (function).
• f2$line (macro).
• f2$point (macro).
• f2$polygon (function).
• f2$rect (macro).
• f2$square* (function).
• f3$line (macro).
• f3$point (macro).
• f4$line (macro).
• f4$point (macro).
• i$line (macro).
• i$point (macro).
• i2$line (macro).
• i2$point (macro).
• i3$line (macro).
• i3$point (macro).
• i4$line (macro).
• i4$point (macro).
• p$line (macro).
• p$point (macro).
• p2$line (macro).
• p2$point (macro).
• p3$line (macro).
• p3$point (macro).
• p4$line (macro).
• p4$point (macro).

Internals

• %d$line (function).
• %d$point (function).
• %d2$line (function).
• %d2$point (function).
• %d3$line (function).
• %d3$point (function).
• %d4$line (function).
• %d4$point (function).
• %f$line (function).
• %f$point (function).
• %f2$line (function).
• %f2$point (function).
• %f2$rect (function).
• %f3$line (function).
• %f3$point (function).
• %f4$line (function).
• %f4$point (function).
• %i$line (function).
• %i$point (function).
• %i2$line (function).
• %i2$point (function).
• %i3$line (function).
• %i3$point (function).
• %i4$line (function).
• %i4$point (function).
• %p$line (function).
• %p$point (function).
• %p2$line (function).
• %p2$point (function).
• %p3$line (function).
• %p3$point (function).
• %p4$line (function).
• %p4$point (function).
• define-arr-shape (macro).

---

3.1.30 veq/easing.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

• dease-in-back (function).
• dease-in-circ (function).
• dease-in-cubic (function).
• dease-in-elastic (function).
• dease-in-exp (function).
• dease-in-linear (function).
• dease-in-out-back (function).
• dease-in-out-circ (function).
• dease-in-out-cubic (function).
• dease-in-out-elastic (function).
• dease-in-out-exp (function).
• dease-in-out-linear (function).
• dease-in-out-quart (function).
• dease-in-out-quint (function).
• dease-in-out-sin (function).
• dease-in-quart (function).
• dease-in-quint (function).
• dease-in-sin (function).
• dease-out-back (function).
• dease-out-circ (function).
• dease-out-cubic (function).
• dease-out-elastic (function).
• dease-out-exp (function).
• dease-out-linear (function).
• dease-out-quart (function).
• dease-out-quint (function).
• dease-out-sin (function).
• fease-in-back (function).
• fease-in-circ (function).
• fease-in-cubic (function).
• fease-in-elastic (function).
• fease-in-exp (function).
• fease-in-linear (function).
• fease-in-out-back (function).
• fease-in-out-circ (function).
• fease-in-out-cubic (function).
• fease-in-out-elastic (function).
• fease-in-out-exp (function).
• fease-in-out-linear (function).
• fease-in-out-quart (function).
• fease-in-out-quint (function).
• fease-in-out-sin (function).
• fease-in-quart (function).
• fease-in-quint (function).
• fease-in-sin (function).
• fease-out-back (function).
• fease-out-circ (function).
• fease-out-cubic (function).
• fease-out-elastic (function).
• fease-out-exp (function).
• fease-out-linear (function).
• fease-out-quart (function).
• fease-out-quint (function).
• fease-out-sin (function).

Internals

easing-op (macro).

---

5.1.1 Constants

Constant: dpi ¶

Package

veq.

Source

utils.lisp.

Constant: dpi25 ¶

Package

veq.

Source

utils.lisp.

Constant: dpi5 ¶

Package

veq.

Source

utils.lisp.

Constant: dpii ¶

Package

veq.

Source

utils.lisp.

Constant: fpi ¶

Package

veq.

Source

utils.lisp.

Constant: fpi25 ¶

Package

veq.

Source

utils.lisp.

Constant: fpi5 ¶

Package

veq.

Source

utils.lisp.

Constant: fpii ¶

Package

veq.

Source

utils.lisp.

---

5.1.2 Special variables

Special Variable: *eps* ¶

Package

veq.

Source

config.lisp.

---

5.1.3 Macros

Macro: $make (&key dim n v type) ¶

create vector array with size (n dim), and initial value v.

Package

veq.

Source

array-utils.lisp.

Macro: $nvset ((a n &optional i) &body body) ¶

set n indices in a, from a[i] with n values from body.

Package

veq.

Source

vset.lisp.

Macro: context? () ¶

list all macrolet symbols (ie. ops available inside vprog, fvprogn, vdef, fvdef defined contexts/functions) and corresponding macro body in veq context.

Package

veq.

Source

docs.lisp.

Macro: d$ (a &rest rest) ¶

returns indices [default: 0] from 1d vector array (DVEC) as values. ex: (D$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: d$line (&rest rest) ¶

WRAPS: %D$LINE
ARGS: ((VA 2 X))
DOCSTRING: init DVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d$lspace (&rest rest) ¶

WRAPS: %D$LSPACE
ARGS: (N (VARG 1 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: d$make (&key dim n v) ¶

create DVEC vector array with size n * dim, and initial value v.

Package

veq.

Source

array-utils.lisp.

Macro: d$point (&rest rest) ¶

WRAPS: %D$POINT
ARGS: ((VA 1 X))
DOCSTRING: init DVEC array with 1 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d$~ ((&optional n) &body body) ¶

create DVEC vector array from n values in body.

Package

veq.

Source

array-utils.lisp.

Macro: d2$ (a &rest rest) ¶

returns indices [default: 0] from 2d vector array (DVEC) as values. ex: (D2$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: d2$line (&rest rest) ¶

WRAPS: %D2$LINE
ARGS: ((VA 4 X))
DOCSTRING: init DVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d2$lspace (&rest rest) ¶

WRAPS: %D2$LSPACE
ARGS: (N (VARG 2 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: d2$point (&rest rest) ¶

WRAPS: %D2$POINT
ARGS: ((VA 2 X))
DOCSTRING: init DVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d2mm (a*433 b*435) ¶

multiply mat * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mmt (a*505 b*507) ¶

multiply mat * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mrot (&rest rest) ¶

WRAPS: %D2MROT
ARGS: (A)
DOCSTRING: make 2d rotation matrix for rotating a rads defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: d2mrot* (&rest rest) ¶

WRAPS: %D2MROT*
ARGS: (A)
DOCSTRING: make 2d rotation matrix for rotating a rads defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: d2mscale (&rest rest) ¶

WRAPS: %D2MSCALE
ARGS: ((VARG 2 X))
DOCSTRING: make 2d matrix for scaling by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: d2mt! (a1) ¶

transpose 2d matrix in-place.

Package

veq.

Source

mat.lisp.

Macro: d2mtm (a*541 b*543) ¶

multiply (transpose mat) * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mtmt (a*469 b*471) ¶

multiply (transpose mat) * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mtrans (&rest rest) ¶

WRAPS: %D2MTRANS
ARGS: ((VARG 2 X))
DOCSTRING: make 2d transpose matrix for moving by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: d2mtv (m1 &rest v2) ¶

transpose(mat) * v. for 2d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: d2mv (m1 &rest v2) ¶

mat * v. for 2d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: d3$ (a &rest rest) ¶

returns indices [default: 0] from 3d vector array (DVEC) as values. ex: (D3$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: d3$line (&rest rest) ¶

WRAPS: %D3$LINE
ARGS: ((VA 6 X))
DOCSTRING: init DVEC array with 6 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d3$lspace (&rest rest) ¶

WRAPS: %D3$LSPACE
ARGS: (N (VARG 3 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: d3$point (&rest rest) ¶

WRAPS: %D3$POINT
ARGS: ((VA 3 X))
DOCSTRING: init DVEC array with 3 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d3mm (a*577 b*579) ¶

multiply mat * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mmt (a*649 b*651) ¶

multiply mat * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mrot (&rest rest) ¶

WRAPS: %D3MROT
ARGS: (A X Y Z)
DOCSTRING: make 3d rotation matrix for rotating a rad around unit vector (x y z) defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: d3mrot* (&rest rest) ¶

WRAPS: %D3MROT*
ARGS: (A X Y Z)
DOCSTRING: make 3d rotation matrix for rotating a rad around unit vector (x y z) defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: d3mscale (&rest rest) ¶

WRAPS: %D3MSCALE
ARGS: ((VARG 3 X))
DOCSTRING: make 3d matrix for scaling by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: d3mt! (a1) ¶

transpose 3d matrix in-place.

Package

veq.

Source

mat.lisp.

Macro: d3mtm (a*685 b*687) ¶

multiply (transpose mat) * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mtmt (a*613 b*615) ¶

multiply (transpose mat) * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mtrans (&rest rest) ¶

WRAPS: %D3MTRANS
ARGS: ((VARG 3 X))
DOCSTRING: make 3d transpose matrix for moving by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: d3mtv (m1 &rest v2) ¶

transpose(mat) * v. for 3d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: d3mv (m1 &rest v2) ¶

mat * v. for 3d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: d4$ (a &rest rest) ¶

returns indices [default: 0] from 4d vector array (DVEC) as values. ex: (D4$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: d4$line (&rest rest) ¶

WRAPS: %D4$LINE
ARGS: ((VA 8 X))
DOCSTRING: init DVEC array with 8 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d4$lspace (&rest rest) ¶

WRAPS: %D4$LSPACE
ARGS: (N (VARG 4 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: d4$point (&rest rest) ¶

WRAPS: %D4$POINT
ARGS: ((VA 4 X))
DOCSTRING: init DVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: d4mm (a*721 b*723) ¶

multiply mat * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d4mmt (a*793 b*795) ¶

multiply mat * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d4mt! (a1) ¶

transpose 4d matrix in-place.

Package

veq.

Source

mat.lisp.

Macro: d4mtm (a*829 b*831) ¶

multiply (transpose mat) * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d4mtmt (a*757 b*759) ¶

multiply (transpose mat) * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d4mtv (m1 &rest v2) ¶

transpose(mat) * v. for 4d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: d4mv (m1 &rest v2) ¶

mat * v. for 4d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: d_ (&body body) ¶

create DVEC vector array from body: (D_ ’(a b c ...)).

Package

veq.

Source

array-utils.lisp.

Macro: def* (mname &body body) ¶

defines a function named: %mname
and a wrapper macro named: mname

the wrapper macro ensures every call to this function is done as (mvc #’%mname ...).

Package

veq.

Source

macrolets.lisp.

Macro: df* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: dsb (&rest args) ¶

Package

veq.

Source

generic-utils.lisp.

Macro: dsel ((&rest dims) &body body) ¶

return values from body in order of dims.
use indices or :x :y :z :w
ex: (DSEL (:w :zx 0) (values a b c d)) returns: (values d c a a).

Package

veq.

Source

select-dim.lisp.

Macro: ext-symbols? (&optional mode) ¶

list all external symbols in veq. use :verbose to inlcude docstring. use :pretty to print verbose output to stdout in a readable form.

Package

veq.

Source

docs.lisp.

Macro: f$ (a &rest rest) ¶

returns indices [default: 0] from 1d vector array (FVEC) as values. ex: (F$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: f$line (&rest rest) ¶

WRAPS: %F$LINE
ARGS: ((VA 2 X))
DOCSTRING: init FVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f$lspace (&rest rest) ¶

WRAPS: %F$LSPACE
ARGS: (N (VARG 1 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: f$make (&key dim n v) ¶

create FVEC vector array with size n * dim, and initial value v.

Package

veq.

Source

array-utils.lisp.

Macro: f$point (&rest rest) ¶

WRAPS: %F$POINT
ARGS: ((VA 1 X))
DOCSTRING: init FVEC array with 1 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f$~ ((&optional n) &body body) ¶

create FVEC vector array from n values in body.

Package

veq.

Source

array-utils.lisp.

Macro: f2$ (a &rest rest) ¶

returns indices [default: 0] from 2d vector array (FVEC) as values. ex: (F2$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: f2$line (&rest rest) ¶

WRAPS: %F2$LINE
ARGS: ((VA 4 X))
DOCSTRING: init FVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f2$lspace (&rest rest) ¶

WRAPS: %F2$LSPACE
ARGS: (N (VARG 2 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: f2$point (&rest rest) ¶

WRAPS: %F2$POINT
ARGS: ((VA 2 X))
DOCSTRING: init FVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f2$rect (&rest rest) ¶

WRAPS: %F2$RECT ARGS: (W H) DOCSTRING: [none] defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f2in-bbox (&rest rest) ¶

WRAPS: %F2IN-BBOX
ARGS: ((VARG 2 TOP-LEFT BOTTOM-RIGHT PT)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f2in-concave (&rest rest) ¶

WRAPS: %F2IN-CONCAVE ARGS: (SHAPE (VARG 2 PT)) DOCSTRING: [none] defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f2in-triangle (&rest rest) ¶

WRAPS: %F2IN-TRIANGLE ARGS: ((VARG 2 A B C P)) DOCSTRING: [none] defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f2lsegx (&rest rest) ¶

WRAPS: %F2LSEGX
ARGS: (LINES*)
DOCSTRING: lines = #( #(ax ay bx by) ... )

not entirely slow line-line intersection for all lines. this is faster than comparing all lines when lines are short relative to the area that the lines cover. it can be improved further by using binary search tree to store current state.
defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f2mm (a*1 b*3) ¶

multiply mat * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f2mmt (a*73 b*75) ¶

multiply mat * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f2mrot (&rest rest) ¶

WRAPS: %F2MROT
ARGS: (A)
DOCSTRING: make 2d rotation matrix for rotating a rads defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: f2mrot* (&rest rest) ¶

WRAPS: %F2MROT*
ARGS: (A)
DOCSTRING: make 2d rotation matrix for rotating a rads defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: f2mscale (&rest rest) ¶

WRAPS: %F2MSCALE
ARGS: ((VARG 2 X))
DOCSTRING: make 2d matrix for scaling by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: f2mt! (a1) ¶

transpose 2d matrix in-place.

Package

veq.

Source

mat.lisp.

Macro: f2mtm (a*109 b*111) ¶

multiply (transpose mat) * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f2mtmt (a*37 b*39) ¶

multiply (transpose mat) * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f2mtrans (&rest rest) ¶

WRAPS: %F2MTRANS
ARGS: ((VARG 2 X))
DOCSTRING: make 2d transpose matrix for moving by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: f2mtv (m1 &rest v2) ¶

transpose(mat) * v. for 2d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: f2mv (m1 &rest v2) ¶

mat * v. for 2d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: f2segdst (&rest rest) ¶

WRAPS: %F2SEGDST
ARGS: ((VARG 2 VA VB V))
DOCSTRING: find distance between line, (va vb), and v.
returns (values distance s) where is is the interpolation value that will yield the closest point on line.
defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f2segx (&rest rest) ¶

WRAPS: %F2SEGX
ARGS: ((VARG 2 A1 A2 B1 B2))
DOCSTRING: find intersection between lines (a1 a2), (b1 b2). returns isect? p q where p and q is the distance along each line to the intersection point
defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f3$ (a &rest rest) ¶

returns indices [default: 0] from 3d vector array (FVEC) as values. ex: (F3$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: f3$line (&rest rest) ¶

WRAPS: %F3$LINE
ARGS: ((VA 6 X))
DOCSTRING: init FVEC array with 6 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f3$lspace (&rest rest) ¶

WRAPS: %F3$LSPACE
ARGS: (N (VARG 3 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: f3$point (&rest rest) ¶

WRAPS: %F3$POINT
ARGS: ((VA 3 X))
DOCSTRING: init FVEC array with 3 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f3mm (a*145 b*147) ¶

multiply mat * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mmt (a*217 b*219) ¶

multiply mat * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mrot (&rest rest) ¶

WRAPS: %F3MROT
ARGS: (A X Y Z)
DOCSTRING: make 3d rotation matrix for rotating a rad around unit vector (x y z) defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: f3mrot* (&rest rest) ¶

WRAPS: %F3MROT*
ARGS: (A X Y Z)
DOCSTRING: make 3d rotation matrix for rotating a rad around unit vector (x y z) defined via veq:DEF*

Package

veq.

Source

mat.lisp.

Macro: f3mscale (&rest rest) ¶

WRAPS: %F3MSCALE
ARGS: ((VARG 3 X))
DOCSTRING: make 3d matrix for scaling by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: f3mt! (a1) ¶

transpose 3d matrix in-place.

Package

veq.

Source

mat.lisp.

Macro: f3mtm (a*253 b*255) ¶

multiply (transpose mat) * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mtmt (a*181 b*183) ¶

multiply (transpose mat) * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mtrans (&rest rest) ¶

WRAPS: %F3MTRANS
ARGS: ((VARG 3 X))
DOCSTRING: make 3d transpose matrix for moving by x defined via veq:FVDEF*

Package

veq.

Source

mat.lisp.

Macro: f3mtv (m1 &rest v2) ¶

transpose(mat) * v. for 3d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: f3mv (m1 &rest v2) ¶

mat * v. for 3d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: f3planex (&rest rest) ¶

WRAPS: %F3PLANEX
ARGS: ((VARG 3 N P A B))
DOCSTRING: intersection of plane (n:normal, p:point) and line (a b) defined via veq:FVDEF*

Package

veq.

Source

checks.lisp.

Macro: f4$ (a &rest rest) ¶

returns indices [default: 0] from 4d vector array (FVEC) as values. ex: (F4$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: f4$line (&rest rest) ¶

WRAPS: %F4$LINE
ARGS: ((VA 8 X))
DOCSTRING: init FVEC array with 8 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f4$lspace (&rest rest) ¶

WRAPS: %F4$LSPACE
ARGS: (N (VARG 4 A B) &KEY (END T)) DOCSTRING: [none]
defined via veq:FVDEF*

Package

veq.

Source

fxlspace.lisp.

Macro: f4$point (&rest rest) ¶

WRAPS: %F4$POINT
ARGS: ((VA 4 X))
DOCSTRING: init FVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: f4mm (a*289 b*291) ¶

multiply mat * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f4mmt (a*361 b*363) ¶

multiply mat * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f4mt! (a1) ¶

transpose 4d matrix in-place.

Package

veq.

Source

mat.lisp.

Macro: f4mtm (a*397 b*399) ¶

multiply (transpose mat) * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f4mtmt (a*325 b*327) ¶

multiply (transpose mat) * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f4mtv (m1 &rest v2) ¶

transpose(mat) * v. for 4d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: f4mv (m1 &rest v2) ¶

mat * v. for 4d matrix and vector.

Package

veq.

Source

mat.lisp.

Macro: f_ (&body body) ¶

create FVEC vector array from body: (F_ ’(a b c ...)).

Package

veq.

Source

array-utils.lisp.

Macro: ff* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: fmake-ortho-proj-matrix (&rest rest) ¶

WRAPS: %FMAKE-ORTHO-PROJ-MATRIX
ARGS: (&OPTIONAL (W 1.0) (H W) (N 0.1) (F 100.0)) DOCSTRING: make orthogonal projection matrix defined via veq:FVDEF*

Package

veq.

Source

mat-cam.lisp.

Macro: fmake-proj-matrix (&rest rest) ¶

WRAPS: %FMAKE-PROJ-MATRIX
ARGS: (&OPTIONAL (W 1.0) (H W) (N 0.1) (F 100.0)) DOCSTRING: make projection matrix for width, height, near, far defined via veq:FVDEF*

Package

veq.

Source

mat-cam.lisp.

Macro: fmake-view-matrix (&rest rest) ¶

WRAPS: %FMAKE-VIEW-MATRIX
ARGS: ((VA 3 CAM TARGET UP))
DOCSTRING: make view matrix for cam (w/up) looking at target defined via veq:FVDEF*

Package

veq.

Source

mat-cam.lisp.

Macro: from-lst (l) ¶

return list as values. equivalent to (values-list ...).

Package

veq.

Source

utils.lisp.

Macro: fsel ((&rest dims) &body body) ¶

return values from body in order of dims.
use indices or :x :y :z :w
ex: (FSEL (:w :zx 0) (values a b c d)) returns: (values d c a a).

Package

veq.

Source

select-dim.lisp.

Macro: fvdef (fname &body body) ¶

define function with veq context enabled. see fvprogn.

Package

veq.

Source

macrolets.lisp.

Macro: fvdef* (mname &body body) ¶

defines a function named: %mname
and a wrapper macro named: mname
veq context is enabled. uses fvprogn.

the wrapper macro ensures every call to this function is done as (mvc #’%mname ...).

Package

veq.

Source

macrolets.lisp.

Macro: fvprogn (&body body) ¶

enable veq context inside this progn.
handles propagation and resolution of uses of (varg d var) and (vref var i). also handles vv macro compiler triggers. see vv macro.

works the same way as vprogn. but removes all macrolets that are not directly referenced by a symbol in body. this is faster, but may fail in some cases where body is complex. in the event of errors try vprogn instead.

Package

veq.

Source

macrolets.lisp.

Macro: i$ (a &rest rest) ¶

returns indices [default: 0] from 1d vector array (IVEC) as values. ex: (I$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: i$line (&rest rest) ¶

WRAPS: %I$LINE
ARGS: ((VA 2 X))
DOCSTRING: init IVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i$make (&key dim n v) ¶

create IVEC vector array with size n * dim, and initial value v.

Package

veq.

Source

array-utils.lisp.

Macro: i$point (&rest rest) ¶

WRAPS: %I$POINT
ARGS: ((VA 1 X))
DOCSTRING: init IVEC array with 1 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i$~ ((&optional n) &body body) ¶

create IVEC vector array from n values in body.

Package

veq.

Source

array-utils.lisp.

Macro: i2$ (a &rest rest) ¶

returns indices [default: 0] from 2d vector array (IVEC) as values. ex: (I2$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: i2$line (&rest rest) ¶

WRAPS: %I2$LINE
ARGS: ((VA 4 X))
DOCSTRING: init IVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i2$point (&rest rest) ¶

WRAPS: %I2$POINT
ARGS: ((VA 2 X))
DOCSTRING: init IVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i3$ (a &rest rest) ¶

returns indices [default: 0] from 3d vector array (IVEC) as values. ex: (I3$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: i3$line (&rest rest) ¶

WRAPS: %I3$LINE
ARGS: ((VA 6 X))
DOCSTRING: init IVEC array with 6 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i3$point (&rest rest) ¶

WRAPS: %I3$POINT
ARGS: ((VA 3 X))
DOCSTRING: init IVEC array with 3 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i4$ (a &rest rest) ¶

returns indices [default: 0] from 4d vector array (IVEC) as values. ex: (I4$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: i4$line (&rest rest) ¶

WRAPS: %I4$LINE
ARGS: ((VA 8 X))
DOCSTRING: init IVEC array with 8 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i4$point (&rest rest) ¶

WRAPS: %I4$POINT
ARGS: ((VA 4 X))
DOCSTRING: init IVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: i_ (&body body) ¶

create IVEC vector array from body: (I_ ’(a b c ...)).

Package

veq.

Source

array-utils.lisp.

Macro: in* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: isel ((&rest dims) &body body) ¶

return values from body in order of dims.
use indices or :x :y :z :w
ex: (ISEL (:w :zx 0) (values a b c d)) returns: (values d c a a).

Package

veq.

Source

select-dim.lisp.

Macro: kv* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: ll* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: lst (&body body) ¶

get all (values ... ) in body as a list.
almost like multiple-value-list, except it handles multiple arguments.

Package

veq.

Source

utils.lisp.

Macro: mac (expr) ¶

expand macro.

Package

veq.

Source

generic-utils.lisp.

Macro: mac* (expr) ¶

expand macro all. only in SBCL.

Package

veq.

Source

generic-utils.lisp.

Macro: mvb (&rest args) ¶

Package

veq.

Source

generic-utils.lisp.

Macro: mvc (&rest args) ¶

Package

veq.

Source

generic-utils.lisp.

Macro: mvcgrp ((dim fx) &body body) ¶

call fx on body in groups of dim.
ex: (labels ((fx ((:va 3 x)) (fsel (:xy) x)))
(vpr (mvcgrp (3 #’fx) (values 1f0 2f0 3f0 4f0 5f0 6f0)))) returns: (values 1f0 2f0 4f0 5f0)
ex: (labels ((fx ((:va 3 x)) (fsel (:xz) x)))
(vpr (mvcgrp (3 #’fx) (values 1f0 2f0 3f0 4f0 5f0 6f0)))) returns: (values 1f0 3f0 4f0 6f0)

Package

veq.

Source

utils.lisp.

Macro: mvcmap ((dim fx) &body body) ¶

returns (values (fx i) (fx j) ...) for dim values from body.

Package

veq.

Source

utils.lisp.

Macro: new-stride ((from to type &optional v) arr) ¶

shift arr from stride to stride.

Package

veq.

Source

array-utils.lisp.

Macro: p$ (a &rest rest) ¶

returns indices [default: 0] from 1d vector array (PVEC) as values. ex: (P$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: p$line (&rest rest) ¶

WRAPS: %P$LINE
ARGS: ((VA 2 X))
DOCSTRING: init PVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p$make (&key dim n v) ¶

create PVEC vector array with size n * dim, and initial value v.

Package

veq.

Source

array-utils.lisp.

Macro: p$point (&rest rest) ¶

WRAPS: %P$POINT
ARGS: ((VA 1 X))
DOCSTRING: init PVEC array with 1 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p$~ ((&optional n) &body body) ¶

create PVEC vector array from n values in body.

Package

veq.

Source

array-utils.lisp.

Macro: p2$ (a &rest rest) ¶

returns indices [default: 0] from 2d vector array (PVEC) as values. ex: (P2$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: p2$line (&rest rest) ¶

WRAPS: %P2$LINE
ARGS: ((VA 4 X))
DOCSTRING: init PVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p2$point (&rest rest) ¶

WRAPS: %P2$POINT
ARGS: ((VA 2 X))
DOCSTRING: init PVEC array with 2 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p3$ (a &rest rest) ¶

returns indices [default: 0] from 3d vector array (PVEC) as values. ex: (P3$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: p3$line (&rest rest) ¶

WRAPS: %P3$LINE
ARGS: ((VA 6 X))
DOCSTRING: init PVEC array with 6 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p3$point (&rest rest) ¶

WRAPS: %P3$POINT
ARGS: ((VA 3 X))
DOCSTRING: init PVEC array with 3 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p4$ (a &rest rest) ¶

returns indices [default: 0] from 4d vector array (PVEC) as values. ex: (P4$ a i j ...) returns (values a[i] .. a[j] .. ...).
note that the number of values depends on the dimension.

Package

veq.

Source

array-utils.lisp.

Macro: p4$line (&rest rest) ¶

WRAPS: %P4$LINE
ARGS: ((VA 8 X))
DOCSTRING: init PVEC array with 8 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p4$point (&rest rest) ¶

WRAPS: %P4$POINT
ARGS: ((VA 4 X))
DOCSTRING: init PVEC array with 4 elements. defined via veq:FVDEF*

Package

veq.

Source

shapes.lisp.

Macro: p_ (&body body) ¶

create PVEC vector array from body: (P_ ’(a b c ...)).

Package

veq.

Source

array-utils.lisp.

Macro: pn* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: psel ((&rest dims) &body body) ¶

return values from body in order of dims.
use indices or :x :y :z :w
ex: (PSEL (:w :zx 0) (values a b c d)) returns: (values d c a a).

Package

veq.

Source

select-dim.lisp.

Macro: sy* (&body body) ¶

Package

veq.

Source

types.lisp.

Macro: vchain (fxs &rest rest) ¶

chain functions, on all values.
eg: (vchain #’a #’b (values 1 2)) corresponds to: (~ #’a (~ #b (values 1 2)))

Package

veq.

Source

utils.lisp.

Macro: vdef (fname &body body) ¶

define function with veq context enabled. see vprogn.

Package

veq.

Source

macrolets.lisp.

Macro: vdef* (mname &body body) ¶

defines a function named: %mname
and a wrapper macro named: mname
veq context is enabled. uses vprogn.

the wrapper macro ensures every call to this function is done as (mvc #’%mname ...).

Package

veq.

Source

macrolets.lisp.

Macro: vlabels ((&rest labs) &body body) ¶

wraps labels so that it can be used with implicit mvc. that is, all labels are defined as if with def*.
use %labelname to call the function directly.

Package

veq.

Source

lets.lisp.

Macro: vnrep (n &rest rest) ¶

corresponds to (~ r1 ... rn)

Package

veq.

Source

utils.lisp.

Macro: vnval (n &rest rest) ¶

returns (values v ...), where v is (progn ,@rest) evaluated once.

Package

veq.

Source

utils.lisp.

Macro: vp (&rest rest) ¶

print values and return values, return values.

Package

veq.

Source

utils.lisp.

Macro: vpr (&rest rest) ¶

print input code with resulting values, return values.

Package

veq.

Source

utils.lisp.

Macro: vprogn (&body body) ¶

enable veq context inside this progn.
handles propagation and resolution of uses of (varg d var) and (vref var i). also handles vv macro compiler triggers. see vv macro.

fvprogn is faster, but has some limitations.

Package

veq.

Source

macrolets.lisp.

Macro: vsel ((type &rest dims) &body body) ¶

return values from body in order of dims.
use indices or :x :y :z :w
ex: (VSEL (df :w :zx 0) (values a b c d)) returns: (values d c a a).

Package

veq.

Source

select-dim.lisp.

Macro: vv (&body body) ¶

the vv macro implements a DSL for manipulating packs of values and/or row
vectors. it is called as a part of vprogn, fvprogn, vdef and fvdef. but can
also be used explicitly via the (vv ...) macro or (veq::vv-proc ...) function.

you can read about the motivation behind vv at: https://inconvergent.net/2023/a-vector-dsl/

the DSL uses triggers to broadcast a function (symbol name) or code across
packs of 1-9 values and/or rows of 1-9 item vectors.

; lets start with a simple example

(i2!@+ 1 2 3 4) ; -> (values (+ 1 3) (+ 2 4))

; where:
; - i is the type (fixnum)
; - 2 is the dimension / size of the value packs
; - !@ is the trigger for this particular mode; and
; - + is the function name

; i2!@+ requires 4 values, but it is agnostic to the grouping of the values in
; the input

(i2!@+ (values 1 2) 3 4) ; -> (values (+ 1 3) (+ 2 4))
(i2!@+ 1 (values 1 2 3 4)) ; -> (values (+ 1 3) (+ 2 4))
(i2!@+ 1 (values 2 3) (+ 7 8)) ; -> (values (+ 1 3) (+ 2 (+ 7 8)))

; here are other possible configurations for !@

; same behaviouir as above
(2!@* 1 2 3 4) ; -> (values (* 1 3) (* 2 4))
; project last value
(2!@*. 1 2 3) ; -> (values (* 1 3) (* 2 3))
; project first value
(2!@.* 1 2 3) ; -> (values (* 1 2) (* 1 3))
; project two values on r side
(2!@*.. 1 2 3 4) ; -> (values (* 1 3 4) (* 2 3 4))

; several modes also support arrays ($)

; array on l side
(2!@$* #(1 2 3 4) 5 6) ; -> #((* 1 5) (* 2 6)
; (* 3 5) (* 4 6))
(2!@$*. #(1 2 3 4) 5) ; -> #((* 1 5) (* 2 5)
; (* 3 5) (* 4 5))
; array on both sides
(2!@$+$! #(1 2 3 4) #(10 20 30 40)) ; -> #(11 22 33 44)
; array on r side only is currently not supported

; expressions can be nested, so a 2d dot product might look like this

(2_@+ (2!@* (values 1 2)
(values 3 4))) ; -> (+ (* 1 3) (* 2 4))

; here we introduce another mode (_@) that will call the function on the input
; values. a simpler example

(2_@+ (values 2 3)) ; -> 5

; so, if you have two arrays, you can do row-wise dot products in a similar way

(21_@$+ (2!@$*$ #(2 2 3 4)
#(4 3 2 1))) ; -> #(14 10)

; notice that 21_@$+ has two dimension digits. the second digit is the expected
; output dimension. as such this command will reduce the number of columns from
; 2 to 1. by default the output dim is the same as the input dim. output
; dimension is supported on all array ($) modes.

; here are some slightly more involved examples using the _@ mode

(labels ((swap (x y) (values y x))
(do-thing (x y z) (values (+ y z) (+ x z))))
; swap columns on each row
(2_@$swap #(2 1 4 3)) ; -> #(1 2 3 4)
; swap columns on each row
(2_@$swap (?@ #(2 1 4 3))) ; -> #(1 2 3 4)
; swap columns in place (!) on all rows except 0
(2_@$swap! (?@ #(2 1 4 3 6 5) 1)) ; -> #(2 1 3 4 5 6)
; project 5 and call do-thing on each row
(2_@$do-thing. #(1 2 3 4) 5)) ; -> #((+ 2 5) (+ 1 5)
; (+ 4 5) (+ 3 5))

; as opposed to calling a function on rows or values, you can use .@ to call a function on all elements

(2.@abs -1 -2) ; -> (values (abs -1) (abs -2))

; or with arrays

(2.@$abs #(-1 -2 -3 -4)) ; -> #((abs -1) (abs -2)
; (abs -3) (abs -4))

; slicing will still work as in the previous examples

(2.@$abs! (?@ #(-1 -2 -3 -4) 1)) ; -> #(-1 -2 (abs -3) (abs -4))

(m@list 1 (values 2 3) 4) ; -> ’(1 2 3 4)

; prints array in two rows with row number:
(2x@$fx #(1 2 3 4) ((i x y) (print (list i :xy x y)))) ; -> nil
; > (0 :xy 1 2)
; > (1 :xy 3 4)

; fcos-sin returns points on a circle at 10 angles,
; then scales the circle by 8f0
; f12 means that fcos-sin takes 1 value and returns 2 values (per row)
(f2!@$*. (veq::f12_@$fcos-sin ; must use :: if outside veq
(veq:f$lspace 10 0f0 veq:fpii))
8f0) ; -> #(8.0 0.0 ...)

; sum all rows:
(2r@$+ #(0 1 2 3 4 5 6 7 8 9)) ; -> (values (+ 0 2 4 6 8) (+ 1 3 5 7 9))
; sum all rows from row 2:
(2r@$+ (?@ #(0 1 2 3 4 5 6 7 8 9) 2)) ; -> (values (+ 4 6 8) (+ 5 7 9))
; sum rows 0 1 3 from vector with indices:
(2r@$+ (v?@ #(0 1 2 3 4 5 6 7 8 9) #(0 1 3))) ; -> (values (+ 0 2 6) (+ 1 3 7)) ; or, using an index list:
(2r@$+ (l?@ #(0 1 2 3 4 5 6 7 8 9) ’(0 1 3))) ; -> (values (+ 0 2 6) (+ 1 3 7))

MODES

the current modes and corresponding triggers are as follows:

– d!@: call fx on pairs of values and/or rows of values from arrays

- d!@fx: d values, d values
- d!@fx.: d values, [number of dots] values
- d!@$fx: d array, d values
- d!@$fx$: d array, d array
- d!@$fx.: d array, [number of dots] values

– _@: call fx on n values, or rows of values from array

- d_@fx: d values
- d_@$fx: d array
- d_@$fx.: d array, [number of dots] values

– d.@: call fx on individual elements from values, rows of values from array

- d.@fx: d values
- d.@$fx: d array

the following modes have more specific behaviour:

- d%@$fx: map fx across rows of values from array. see below.
- dr@$fx: reduce rows with fx vertically. see below.

- m@fx: translates to (mvc #’fx ...)

- ?@ is a modifier used to alter the behaviour of a specific mode.

MODE MODIFIERS: ARRAY SLICING/INDEXING

modes that involve arrays ($) support slicing rows by wrapping the array in

(?@ arr from [to])

for ivec, pvec, list or vector indices, append i, p, l or v respective to the modifier. here are some examples of behaviour. the types are described below.

(labels ((take2 ((:va 2 x)) (values x)))

; slice from index
(2_@$take2 (?@ #(1 2 3 4 5 6 7 8) 2)) ; -> #(5 6 7 8)
; slice to from index
(2_@$take2 (?@ #(1 2 3 4 5 6 7 8) 2 3)) ; -> #(5 6)

; vector index
(2_@$take2 (v?@ #(1 2 3 4 5 6 7 8) #(0 3))) ; -> #(1 2 7 8)
; list index
(2_@$take2 (l?@ #(1 2 3 4 5 6 7 8) ’(0 3))) ; -> #(1 2 7 8)

; individual modifiers can be used for l or r side
(2!@$+$ (?@ #(1 2 3 4) 1) (?@ #(10 20 30 40) 0 1)) ; -> #(13 24)

; if the operation is in-place (!) the l array will
; be changed, by the l index
(2!@$+$! (?@ #(1 2 3 4) 1) (?@ #(10 20 30 40) 0 1))) ; -> #(1 2 13 24)

TYPES

all vv vv expressions (except m@ where it does not make sense) can be explicity typed. the supported types, wtih corresponding array type are as follows

- f: veq:ff, single-float; veq:fvec
- d: veq:df, double-float; veq:dvec
- i: veq:in, fixnum, veq:ivec
- p: veq:pn, (unsigned-byte 31); veq:pvec
- s: veq:sy, symbol; veq:svec
- k: veq:kv, keyword; veq:kvec
- l: veq:ll, list; veq:lvec
- none; vector

fvec, ivec, etc are simple-arrays with the coresponding type. ie. veq:fvec
means (simple-array veq:ff). when type is omitted, the code will be more
forgiving, but less efficeint. in which case the corresponding array type is ’vector.

INSPECT CODE

the code that is actually generated is usually a little more involved than what these examples imply. in order to see the expanded code, the easiset is to wrap
the code in veq:mac, which displays the code after it has been expanded:

(veq:fvprogn (veq:mac (2!@$*. #(1 2 3 4) 5)))

alternatively, use:

(print (veq::vv-proc ’(2!@$*. #(1 2 3 4) 5)))

Package

veq.

Source

ops-vv.lisp.

Macro: xlet (all-vars &body body) ¶

xlet is a macro to bind typed values, and other variables: (veq:xlet ((f2!a (f2 1f0 2f0)) ; 2d veq:ff/float
(d!b 1d0) ; 1d veq:df/double
(h :a)
(i4!c (values 1 2 3 4))) ; 4d veq:in/integer (declare (keyword h))
(do-something a b c h))

names without ! will be treated (mostly) as in a regular let. declare can be used to declare types.
NOTE: xlet behaves more like CL let* in that bindings are available immediately.

Package

veq.

Source

lets.lisp.

Macro: ~ (&rest rest) ¶

wraps arguments in (mvc #’values ...).

Package

veq.

Source

utils.lisp.

---