The veq Reference Manual

This is the veq Reference Manual, version 4.5.5, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed May 15 04:36:39 2024 GMT+0.

Table of Contents


1 Introduction


2 Systems

The main system appears first, followed by any subsystem dependency.


2.1 veq

reasonably fast operations for 1-4d vectors, matrices, and arrays of vectors.

Author

<>

License

MIT

Version

4.5.5

Dependency

sb-cltl2 (system).

Source

veq.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


3.1 Lisp


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

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
Internals

3.1.6 veq/types.lisp

Dependency

generic-utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

3.1.7 veq/utils.lisp

Dependency

types.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

define-constants (macro).


3.1.8 veq/docs.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.9 veq/vset.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

make-$defsetf (macro).


3.1.10 veq/lets.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.11 veq/macros-helpers.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

replace-varg (function).

Internals

3.1.12 veq/veq-ops.lisp

Dependency

macros-helpers.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.13 veq/ops-1.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.14 veq/ops-2.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.15 veq/ops-3.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.16 veq/ops-4.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.17 veq/macrolets.lisp

Dependencies
Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.18 veq/ops-vv-helpers.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

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

3.1.20 veq/array-utils.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.21 veq/array-rows.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.22 veq/select-dim.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

define-vsel (macro).


3.1.23 veq/fxlspace.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.24 veq/mat.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.25 veq/mat-inv.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.26 veq/mat-cam.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.27 veq/array-extra.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

-xmima (macro).


3.1.28 veq/checks.lisp

Dependency

array-extra.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.29 veq/shapes.lisp

Dependency

array-extra.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.30 veq/easing.lisp

Dependency

macrolets.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

easing-op (macro).


4 Packages

Packages are listed by definition order.


4.1 veq

Source

packages.lisp.

Use List

common-lisp.

Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


5.1 Public Interface


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.


5.1.4 Setf expanders

Setf Expander: (setf $) (a0 &optional i1)

get: ($ a i) yields (values ...) set: (setf ($ a i) (values ...))

Package

veq.

Source

vset.lisp.

Setf Expander: (setf 2$) (a0 &optional i1)

get: (2$ a i) yields (values ...) set: (setf (2$ a i) (values ...))

Package

veq.

Source

vset.lisp.

Setf Expander: (setf 3$) (a0 &optional i1)

get: (3$ a i) yields (values ...) set: (setf (3$ a i) (values ...))

Package

veq.

Source

vset.lisp.

Setf Expander: (setf 4$) (a0 &optional i1)

get: (4$ a i) yields (values ...) set: (setf (4$ a i) (values ...))

Package

veq.

Source

vset.lisp.


5.1.5 Ordinary functions

Function: $num (a0)

number of elements in 1d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: $print (a &key dim start n s)

pretty print n, or all, rows from vector array of dim. start at row (start 0).
negative start counts backwards from the last row use s to overrid output stream.

Package

veq.

Source

array-extra.lisp.

Function: $to-list (a &key dim)

return array as a list of lists of length dim.

Package

veq.

Source

array-extra.lisp.

Function: 2$num (a0)

number of elements in 2d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: 2$print (a &key n s)

pretty print 2d array. returns array.

Package

veq.

Source

array-extra.lisp.

Function: 2$to-list (a)

return array as a list of lists of length 2.

Package

veq.

Source

array-extra.lisp.

Function: 3$num (a0)

number of elements in 3d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: 3$print (a &key n s)

pretty print 3d array. returns array.

Package

veq.

Source

array-extra.lisp.

Function: 3$to-list (a)

return array as a list of lists of length 3.

Package

veq.

Source

array-extra.lisp.

Function: 4$num (a0)

number of elements in 4d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: 4$print (a &key n s)

pretty print 4d array. returns array.

Package

veq.

Source

array-extra.lisp.

Function: 4$to-list (a)

return array as a list of lists of length 4.

Package

veq.

Source

array-extra.lisp.

Function: arrtype (ty &optional missing)

select array type from type hint. eg: :ff :df ’f ’i

Package

veq.

Source

types.lisp.

Function: d$_ (body)

create DVEC vector array from body. where body is a list of lists. ex: (D$_ (loop repeat 2 collect ‘(1f0 2f0)))
ex: (D$_ ’((1f0 2f0) (1f0 2f0))).

Package

veq.

Source

array-utils.lisp.

Function: d$copy (a0)

copy DVEC vector array.

Package

veq.

Source

array-utils.lisp.

Function: d$last (a0)

return values from last row of 1d vector array.

Package

veq.

Source

array-rows.lisp.

Function: d$mima (a &key n inds)

find min and max for all dimensions of 1 array. ex: (D$MIMA &key n) returns (values xmin xmax ...). use n to limit to first n rows.

Package

veq.

Source

array-extra.lisp.

Function: d$num (a0)

number of elements in 1d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: d$one (&optional n1)

make 1d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: d$val (v &optional n1)

make 1d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: d$zero (&optional n1)

make 1d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: d2$last (a0)

return values from last row of 2d vector array.

Package

veq.

Source

array-rows.lisp.

Function: d2$mima (a &key n inds)

find min and max for all dimensions of 2 array. ex: (D2$MIMA &key n) returns (values xmin xmax ...). use n to limit to first n rows.

Package

veq.

Source

array-extra.lisp.

Function: d2$num (a0)

number of elements in 2d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: d2$one (&optional n1)

make 2d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: d2$val (v &optional n1)

make 2d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: d2$zero (&optional n1)

make 2d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: d2meye (&optional v)

return 2d eye matrix.

Package

veq.

Source

mat.lisp.

Function: d2minv (a)

invert 2x2 matrix. non-destructive.

Package

veq.

Source

mat-inv.lisp.

Function: d3$last (a0)

return values from last row of 3d vector array.

Package

veq.

Source

array-rows.lisp.

Function: d3$mima (a &key n inds)

find min and max for all dimensions of 3 array. ex: (D3$MIMA &key n) returns (values xmin xmax ...). use n to limit to first n rows.

Package

veq.

Source

array-extra.lisp.

Function: d3$num (a0)

number of elements in 3d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: d3$one (&optional n1)

make 3d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: d3$val (v &optional n1)

make 3d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: d3$zero (&optional n1)

make 3d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: d3meye (&optional v)

return 3d eye matrix.

Package

veq.

Source

mat.lisp.

Function: d3minv (a0)

invert 3x3 matrix. non-destructive.

Package

veq.

Source

mat-inv.lisp.

Function: d4$last (a0)

return values from last row of 4d vector array.

Package

veq.

Source

array-rows.lisp.

Function: d4$num (a0)

number of elements in 4d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: d4$one (&optional n1)

make 4d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: d4$val (v &optional n1)

make 4d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: d4$zero (&optional n1)

make 4d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: d4meye (&optional v)

return 4d eye matrix.

Package

veq.

Source

mat.lisp.

Function: d4minv (a0)

invert 4x4 matrix. non-destructive.

Package

veq.

Source

mat-inv.lisp.

Function: d? (f)

describe argument

Package

veq.

Source

config.lisp.

Function: dease-in-back (x &optional s)

ease in:
arg: (X &OPTIONAL (S 1.70158)) body: (* X X (- (* (+ 1.0d0 S) X) S))

Package

veq.

Source

easing.lisp.

Function: dease-in-circ (x)

ease in:
arg: (X)
body: (- (- (SQRT (- 1.0d0 (* X X))) 1.0d0))

Package

veq.

Source

easing.lisp.

Function: dease-in-cubic (x)

ease in: arg: (X) body: (* X X X)

Package

veq.

Source

easing.lisp.

Function: dease-in-elastic (x &optional p s)

ease in:
arg: (X &OPTIONAL (P 0.3) (S NIL))
body: (LET ((S (OR S (* (ASIN 1.0d0) (/ P DPII))))) (-
(* (EXPT 2.0d0 (* 10.0d0 (- X 1)))
(SIN (/ (* (- (- X 1.0d0) S) DPII) P)))))

Package

veq.

Source

easing.lisp.

Function: dease-in-exp (x)

ease in:
arg: (X)
body: (EXPT 2.0d0 (* 10.0d0 (- X 1)))

Package

veq.

Source

easing.lisp.

Function: dease-in-linear (x)

ease in: arg: (X) body: X

Package

veq.

Source

easing.lisp.

Function: dease-in-out-back (x &optional s)

ease in-out:
arg: (X &OPTIONAL (S 1.70158)) body: (* X X (- (* (+ 1.0d0 S) X) S))

Package

veq.

Source

easing.lisp.

Function: dease-in-out-circ (x)

ease in-out:
arg: (X)
body: (- (- (SQRT (- 1.0d0 (* X X))) 1.0d0))

Package

veq.

Source

easing.lisp.

Function: dease-in-out-cubic (x)

ease in-out: arg: (X) body: (* X X X)

Package

veq.

Source

easing.lisp.

Function: dease-in-out-elastic (x &optional p s)

ease in-out:
arg: (X &OPTIONAL (P 0.3) (S NIL))
body: (LET ((S (OR S (* (ASIN 1.0d0) (/ P DPII))))) (-
(* (EXPT 2.0d0 (* 10.0d0 (- X 1)))
(SIN (/ (* (- (- X 1.0d0) S) DPII) P)))))

Package

veq.

Source

easing.lisp.

Function: dease-in-out-exp (x)

ease in-out:
arg: (X)
body: (EXPT 2.0d0 (* 10.0d0 (- X 1)))

Package

veq.

Source

easing.lisp.

Function: dease-in-out-linear (x)

ease in-out: arg: (X) body: X

Package

veq.

Source

easing.lisp.

Function: dease-in-out-quart (x)

ease in-out: arg: (X)
body: (EXPT X 4.0d0)

Package

veq.

Source

easing.lisp.

Function: dease-in-out-quint (x)

ease in-out: arg: (X)
body: (EXPT X 5.0d0)

Package

veq.

Source

easing.lisp.

Function: dease-in-out-sin (x)

ease in-out:
arg: (X)
body: (- 1.0d0 (COS (* X DPI5)))

Package

veq.

Source

easing.lisp.

Function: dease-in-quart (x)

ease in:
arg: (X)
body: (EXPT X 4.0d0)

Package

veq.

Source

easing.lisp.

Function: dease-in-quint (x)

ease in:
arg: (X)
body: (EXPT X 5.0d0)

Package

veq.

Source

easing.lisp.

Function: dease-in-sin (x)

ease in:
arg: (X)
body: (- 1.0d0 (COS (* X DPI5)))

Package

veq.

Source

easing.lisp.

Function: dease-out-back (x &optional s)

ease out:
arg: (X &OPTIONAL (S 1.70158)) body: (* X X (- (* (+ 1.0d0 S) X) S))

Package

veq.

Source

easing.lisp.

Function: dease-out-circ (x)

ease out:
arg: (X)
body: (- (- (SQRT (- 1.0d0 (* X X))) 1.0d0))

Package

veq.

Source

easing.lisp.

Function: dease-out-cubic (x)

ease out: arg: (X) body: (* X X X)

Package

veq.

Source

easing.lisp.

Function: dease-out-elastic (x &optional p s)

ease out:
arg: (X &OPTIONAL (P 0.3) (S NIL))
body: (LET ((S (OR S (* (ASIN 1.0d0) (/ P DPII))))) (-
(* (EXPT 2.0d0 (* 10.0d0 (- X 1)))
(SIN (/ (* (- (- X 1.0d0) S) DPII) P)))))

Package

veq.

Source

easing.lisp.

Function: dease-out-exp (x)

ease out:
arg: (X)
body: (EXPT 2.0d0 (* 10.0d0 (- X 1)))

Package

veq.

Source

easing.lisp.

Function: dease-out-linear (x)

ease out: arg: (X) body: X

Package

veq.

Source

easing.lisp.

Function: dease-out-quart (x)

ease out:
arg: (X)
body: (EXPT X 4.0d0)

Package

veq.

Source

easing.lisp.

Function: dease-out-quint (x)

ease out:
arg: (X)
body: (EXPT X 5.0d0)

Package

veq.

Source

easing.lisp.

Function: dease-out-sin (x)

ease out:
arg: (X)
body: (- 1.0d0 (COS (* X DPI5)))

Package

veq.

Source

easing.lisp.

Function: df (v)
Package

veq.

Source

types.lisp.

Function: dfl (l)

return (values (df a) (df b ..) from (list a b ..).

Package

veq.

Source

types.lisp.

Function: f$_ (body)

create FVEC vector array from body. where body is a list of lists. ex: (F$_ (loop repeat 2 collect ‘(1f0 2f0)))
ex: (F$_ ’((1f0 2f0) (1f0 2f0))).

Package

veq.

Source

array-utils.lisp.

Function: f$copy (a0)

copy FVEC vector array.

Package

veq.

Source

array-utils.lisp.

Function: f$last (a0)

return values from last row of 1d vector array.

Package

veq.

Source

array-rows.lisp.

Function: f$mima (a &key n inds)

find min and max for all dimensions of 1 array. ex: (F$MIMA &key n) returns (values xmin xmax ...). use n to limit to first n rows.

Package

veq.

Source

array-extra.lisp.

Function: f$num (a0)

number of elements in 1d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: f$one (&optional n1)

make 1d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: f$val (v &optional n1)

make 1d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: f$zero (&optional n1)

make 1d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: f2$center (arr)

center 2d array according to n points in array. n is optional.

Package

veq.

Source

shapes.lisp.

Function: f2$circ (rad &optional rs)

return circle of size rad. (rs 0.5) is vertex density.

Package

veq.

Source

shapes.lisp.

Function: f2$last (a0)

return values from last row of 2d vector array.

Package

veq.

Source

array-rows.lisp.

Function: f2$mima (a &key n inds)

find min and max for all dimensions of 2 array. ex: (F2$MIMA &key n) returns (values xmin xmax ...). use n to limit to first n rows.

Package

veq.

Source

array-extra.lisp.

Function: f2$num (a0)

number of elements in 2d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: f2$one (&optional n1)

make 2d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: f2$polygon (n rad &optional rot pin)

return n-polygon of size rad. rotate by (rot 0)

Package

veq.

Source

shapes.lisp.

Function: f2$square* (s)
Package

veq.

Source

shapes.lisp.

Function: f2$val (v &optional n1)

make 2d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: f2$zero (&optional n1)

make 2d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: f2meye (&optional v)

return 2d eye matrix.

Package

veq.

Source

mat.lisp.

Function: f2minv (a)

invert 2x2 matrix. non-destructive.

Package

veq.

Source

mat-inv.lisp.

Function: f3$last (a0)

return values from last row of 3d vector array.

Package

veq.

Source

array-rows.lisp.

Function: f3$mima (a &key n inds)

find min and max for all dimensions of 3 array. ex: (F3$MIMA &key n) returns (values xmin xmax ...). use n to limit to first n rows.

Package

veq.

Source

array-extra.lisp.

Function: f3$num (a0)

number of elements in 3d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: f3$one (&optional n1)

make 3d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: f3$val (v &optional n1)

make 3d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: f3$zero (&optional n1)

make 3d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: f3meye (&optional v)

return 3d eye matrix.

Package

veq.

Source

mat.lisp.

Function: f3minv (a0)

invert 3x3 matrix. non-destructive.

Package

veq.

Source

mat-inv.lisp.

Function: f4$last (a0)

return values from last row of 4d vector array.

Package

veq.

Source

array-rows.lisp.

Function: f4$num (a0)

number of elements in 4d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: f4$one (&optional n1)

make 4d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: f4$val (v &optional n1)

make 4d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: f4$zero (&optional n1)

make 4d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: f4meye (&optional v)

return 4d eye matrix.

Package

veq.

Source

mat.lisp.

Function: f4minv (a0)

invert 4x4 matrix. non-destructive.

Package

veq.

Source

mat-inv.lisp.

Function: fease-in-back (x &optional s)

ease in:
arg: (X &OPTIONAL (S 1.70158)) body: (* X X (- (* (+ 1.0 S) X) S))

Package

veq.

Source

easing.lisp.

Function: fease-in-circ (x)

ease in:
arg: (X)
body: (- (- (SQRT (- 1.0 (* X X))) 1.0))

Package

veq.

Source

easing.lisp.

Function: fease-in-cubic (x)

ease in: arg: (X) body: (* X X X)

Package

veq.

Source

easing.lisp.

Function: fease-in-elastic (x &optional p s)

ease in:
arg: (X &OPTIONAL (P 0.3) (S NIL))
body: (LET ((S (OR S (* (ASIN 1.0) (/ P FPII))))) (-
(* (EXPT 2.0 (* 10.0 (- X 1.0)))
(SIN (/ (* (- (- X 1.0) S) FPII) P)))))

Package

veq.

Source

easing.lisp.

Function: fease-in-exp (x)

ease in:
arg: (X)
body: (EXPT 2.0 (* 10.0 (- X 1.0)))

Package

veq.

Source

easing.lisp.

Function: fease-in-linear (x)

ease in: arg: (X) body: X

Package

veq.

Source

easing.lisp.

Function: fease-in-out-back (x &optional s)

ease in-out:
arg: (X &OPTIONAL (S 1.70158)) body: (* X X (- (* (+ 1.0 S) X) S))

Package

veq.

Source

easing.lisp.

Function: fease-in-out-circ (x)

ease in-out:
arg: (X)
body: (- (- (SQRT (- 1.0 (* X X))) 1.0))

Package

veq.

Source

easing.lisp.

Function: fease-in-out-cubic (x)

ease in-out: arg: (X) body: (* X X X)

Package

veq.

Source

easing.lisp.

Function: fease-in-out-elastic (x &optional p s)

ease in-out:
arg: (X &OPTIONAL (P 0.3) (S NIL))
body: (LET ((S (OR S (* (ASIN 1.0) (/ P FPII))))) (-
(* (EXPT 2.0 (* 10.0 (- X 1.0)))
(SIN (/ (* (- (- X 1.0) S) FPII) P)))))

Package

veq.

Source

easing.lisp.

Function: fease-in-out-exp (x)

ease in-out:
arg: (X)
body: (EXPT 2.0 (* 10.0 (- X 1.0)))

Package

veq.

Source

easing.lisp.

Function: fease-in-out-linear (x)

ease in-out: arg: (X) body: X

Package

veq.

Source

easing.lisp.

Function: fease-in-out-quart (x)

ease in-out: arg: (X)
body: (EXPT X 4.0)

Package

veq.

Source

easing.lisp.

Function: fease-in-out-quint (x)

ease in-out: arg: (X)
body: (EXPT X 5.0)

Package

veq.

Source

easing.lisp.

Function: fease-in-out-sin (x)

ease in-out:
arg: (X)
body: (- 1.0 (COS (* X FPI5)))

Package

veq.

Source

easing.lisp.

Function: fease-in-quart (x)

ease in:
arg: (X)
body: (EXPT X 4.0)

Package

veq.

Source

easing.lisp.

Function: fease-in-quint (x)

ease in:
arg: (X)
body: (EXPT X 5.0)

Package

veq.

Source

easing.lisp.

Function: fease-in-sin (x)

ease in:
arg: (X)
body: (- 1.0 (COS (* X FPI5)))

Package

veq.

Source

easing.lisp.

Function: fease-out-back (x &optional s)

ease out:
arg: (X &OPTIONAL (S 1.70158)) body: (* X X (- (* (+ 1.0 S) X) S))

Package

veq.

Source

easing.lisp.

Function: fease-out-circ (x)

ease out:
arg: (X)
body: (- (- (SQRT (- 1.0 (* X X))) 1.0))

Package

veq.

Source

easing.lisp.

Function: fease-out-cubic (x)

ease out: arg: (X) body: (* X X X)

Package

veq.

Source

easing.lisp.

Function: fease-out-elastic (x &optional p s)

ease out:
arg: (X &OPTIONAL (P 0.3) (S NIL))
body: (LET ((S (OR S (* (ASIN 1.0) (/ P FPII))))) (-
(* (EXPT 2.0 (* 10.0 (- X 1.0)))
(SIN (/ (* (- (- X 1.0) S) FPII) P)))))

Package

veq.

Source

easing.lisp.

Function: fease-out-exp (x)

ease out:
arg: (X)
body: (EXPT 2.0 (* 10.0 (- X 1.0)))

Package

veq.

Source

easing.lisp.

Function: fease-out-linear (x)

ease out: arg: (X) body: X

Package

veq.

Source

easing.lisp.

Function: fease-out-quart (x)

ease out:
arg: (X)
body: (EXPT X 4.0)

Package

veq.

Source

easing.lisp.

Function: fease-out-quint (x)

ease out:
arg: (X)
body: (EXPT X 5.0)

Package

veq.

Source

easing.lisp.

Function: fease-out-sin (x)

ease out:
arg: (X)
body: (- 1.0 (COS (* X FPI5)))

Package

veq.

Source

easing.lisp.

Function: ff (v)
Package

veq.

Source

types.lisp.

Function: ffl (l)

return (values (ff a) (ff b) ..) from (list a b ..).

Package

veq.

Source

types.lisp.

Function: i$_ (body)

create IVEC vector array from body. where body is a list of lists. ex: (I$_ (loop repeat 2 collect ‘(1f0 2f0)))
ex: (I$_ ’((1f0 2f0) (1f0 2f0))).

Package

veq.

Source

array-utils.lisp.

Function: i$copy (a0)

copy IVEC vector array.

Package

veq.

Source

array-utils.lisp.

Function: i$num (a0)

number of elements in 1d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: i$one (&optional n1)

make 1d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: i$val (v &optional n1)

make 1d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: i$zero (&optional n1)

make 1d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: i2$num (a0)

number of elements in 2d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: i2$one (&optional n1)

make 2d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: i2$val (v &optional n1)

make 2d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: i2$zero (&optional n1)

make 2d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: i3$num (a0)

number of elements in 3d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: i3$one (&optional n1)

make 3d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: i3$val (v &optional n1)

make 3d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: i3$zero (&optional n1)

make 3d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: i4$num (a0)

number of elements in 4d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: i4$one (&optional n1)

make 4d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: i4$val (v &optional n1)

make 4d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: i4$zero (&optional n1)

make 4d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: i? (f)

inspect argument

Package

veq.

Source

config.lisp.

Function: in (v)
Package

veq.

Source

types.lisp.

Function: kv (v)
Package

veq.

Source

types.lisp.

Function: ll (v)
Package

veq.

Source

types.lisp.

Function: p$_ (body)

create PVEC vector array from body. where body is a list of lists. ex: (P$_ (loop repeat 2 collect ‘(1f0 2f0)))
ex: (P$_ ’((1f0 2f0) (1f0 2f0))).

Package

veq.

Source

array-utils.lisp.

Function: p$copy (a0)

copy PVEC vector array.

Package

veq.

Source

array-utils.lisp.

Function: p$num (a0)

number of elements in 1d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: p$one (&optional n1)

make 1d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: p$val (v &optional n1)

make 1d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: p$zero (&optional n1)

make 1d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: p2$num (a0)

number of elements in 2d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: p2$one (&optional n1)

make 2d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: p2$val (v &optional n1)

make 2d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: p2$zero (&optional n1)

make 2d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: p3$num (a0)

number of elements in 3d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: p3$one (&optional n1)

make 3d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: p3$val (v &optional n1)

make 3d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: p3$zero (&optional n1)

make 3d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: p4$num (a0)

number of elements in 4d array. typed.

Package

veq.

Source

array-utils.lisp.

Function: p4$one (&optional n1)

make 4d array of ones. typed.

Package

veq.

Source

array-utils.lisp.

Function: p4$val (v &optional n1)

make 4d array of val. typed.

Package

veq.

Source

array-utils.lisp.

Function: p4$zero (&optional n1)

make 4d vector array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: pn (v)
Package

veq.

Source

types.lisp.

Function: replace-varg (body &optional root-rmap)

replace instances of varg/:varg/:va and vref/:vref/:vr with
appropriate symbols for the dimension.

local maps vref/varg maps are propagated forwards in the list so a given arg/ref should be available under its scope. it seems to work for all cases i have tested. but i’m mot sure if this propagation will eventually break somewhere.

ex:
(print (veq:replace-varg ’(mvb ((:va 2 x)) (values 1 2)
(list (:vr x 1 0)))))
; will print something like:
; (MVB (#:X/X-158 #:X/Y-159) (VALUES 1 2)
; (LIST #:X/Y-159 #:X/X-158))

Package

veq.

Source

macros-helpers.lisp.

Function: sy (v)
Package

veq.

Source

types.lisp.

Function: type-default (ty &optional missing)

default value for array with elements of type (hint) ty. eg: 0 0f0 0d0 nil :val

Package

veq.

Source

types.lisp.

Function: type-from-short (ty &optional missing)

select type fom type hint.

Package

veq.

Source

types.lisp.

Function: unpack-vvsym (sym &key s niltype symout)

split names of type f34!var into (values :f var 3 4)

Package

veq.

Source

types.lisp.

Function: v? (&optional silent)

get version. use silent to surpress stdout

Package

veq.

Source

config.lisp.

Function: vvsym (type dim symb &key pref sep pkg)

build a symbol with correct name convention. eg: (vvsym ff 2 :lerp) yields f2lerp.

Package

veq.

Source

types.lisp.


5.1.6 Types

Type: df ()
Package

veq.

Source

types.lisp.

Type: dvec ()
Package

veq.

Source

types.lisp.

Type: ff ()
Package

veq.

Source

types.lisp.

Type: fvec ()
Package

veq.

Source

types.lisp.

Type: in ()
Package

veq.

Source

types.lisp.

Type: ivec ()
Package

veq.

Source

types.lisp.

Type: kv ()
Package

veq.

Source

types.lisp.

Type: kvec ()
Package

veq.

Source

types.lisp.

Type: ll ()
Package

veq.

Source

types.lisp.

Type: lvec ()
Package

veq.

Source

types.lisp.

Type: pn (&optional bits)
Package

veq.

Source

types.lisp.

Type: pos-df ()
Package

veq.

Source

types.lisp.

Type: pos-ff ()
Package

veq.

Source

types.lisp.

Type: pvec ()
Package

veq.

Source

types.lisp.

Type: svec ()
Package

veq.

Source

types.lisp.

Type: sy ()
Package

veq.

Source

types.lisp.


5.2 Internals


5.2.1 Special variables

Special Variable: *dev*
Package

veq.

Source

config.lisp.

Special Variable: *docstring-map*
Package

veq.

Source

docs.lisp.

Special Variable: *errmsg*
Package

veq.

Source

veq-ops.lisp.

Special Variable: *opt*
Package

veq.

Source

config.lisp.

Special Variable: *symbols-map*
Package

veq.

Source

veq-ops.lisp.

Special Variable: *vv-!@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-%@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-.@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-?@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-_@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-arr*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-bang*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-dot*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-f@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-m@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-r@*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-special*
Package

veq.

Source

ops-vv-helpers.lisp.

Special Variable: *vv-x@*
Package

veq.

Source

ops-vv-helpers.lisp.


5.2.2 Macros

Macro: -$ (dim a &key inds atype)
Package

veq.

Source

array-utils.lisp.

Macro: -lspace (dim type)
Package

veq.

Source

fxlspace.lisp.

Macro: -xmima (dim type)
Package

veq.

Source

array-extra.lisp.

Macro: abbrev (short long)
Package

veq.

Source

generic-utils.lisp.

Macro: aif (test-form then-form &optional else-form)
Package

veq.

Source

generic-utils.lisp.

Macro: awf (&rest args)
Package

veq.

Source

generic-utils.lisp.

Macro: awg (&rest args)
Package

veq.

Source

generic-utils.lisp.

Macro: define-$ ()
Package

veq.

Source

array-utils.lisp.

Macro: define-arr-num (dim)
Package

veq.

Source

array-utils.lisp.

Macro: define-arr-shape (n sym)
Package

veq.

Source

shapes.lisp.

Macro: define-arr-util (dim type)
Package

veq.

Source

array-utils.lisp.

Macro: define-constants ()
Package

veq.

Source

utils.lisp.

Macro: define-constr (type)
Package

veq.

Source

array-utils.lisp.

Macro: define-creators ()
Package

veq.

Source

lets.lisp.

Macro: define-def* ()
Package

veq.

Source

macrolets.lisp.

Macro: define-fvdef ()
Package

veq.

Source

macrolets.lisp.

Macro: define-fvdef* ()
Package

veq.

Source

macrolets.lisp.

Macro: define-fvprogn ()
Package

veq.

Source

macrolets.lisp.

Macro: define-rep (dim type)
Package

veq.

Source

lets.lisp.

Macro: define-td (dim type)
Package

veq.

Source

lets.lisp.

Macro: define-td~ (dim type)
Package

veq.

Source

lets.lisp.

Macro: define-val (dim type)
Package

veq.

Source

lets.lisp.

Macro: define-vdef ()
Package

veq.

Source

macrolets.lisp.

Macro: define-vdef* ()
Package

veq.

Source

macrolets.lisp.

Macro: define-vlet (dim type)
Package

veq.

Source

lets.lisp.

Macro: define-vprogn ()
Package

veq.

Source

macrolets.lisp.

Macro: define-vsel (ty)
Package

veq.

Source

select-dim.lisp.

Macro: define-vv-macro ()
Package

veq.

Source

ops-vv.lisp.

Macro: define-xlet-macro ()
Package

veq.

Source

lets.lisp.

Macro: easing-op (type name args &body body)
Package

veq.

Source

easing.lisp.

Macro: init-config (dev-vals vals)
Package

veq.

Source

init.lisp.

Macro: make-$defsetf (dim)
Package

veq.

Source

vset.lisp.

Macro: make-2minv (type)
Package

veq.

Source

mat-inv.lisp.

Macro: make-2mrot (type &optional w)
Package

veq.

Source

mat.lisp.

Macro: make-3minv (type)
Package

veq.

Source

mat-inv.lisp.

Macro: make-3mrot (type &optional w)
Package

veq.

Source

mat.lisp.

Macro: make-4minv (type)
Package

veq.

Source

mat-inv.lisp.

Macro: make-last (dim type)
Package

veq.

Source

array-rows.lisp.

Macro: make-mat-all-mm ()
Package

veq.

Source

mat.lisp.

Macro: make-mat-eye (dim type)
Package

veq.

Source

mat.lisp.

Macro: make-mat-mm (dim type &key ta tb)
Package

veq.

Source

mat.lisp.

Macro: make-mat-mv (dim type &optional transpose)
Package

veq.

Source

mat.lisp.

Macro: make-mat-scale (dim type)
Package

veq.

Source

mat.lisp.

Macro: make-mat-trans (dim type)
Package

veq.

Source

mat.lisp.

Macro: make-mat-transp (dim type)
Package

veq.

Source

mat.lisp.

Macro: map-fxlspace (dim type)
Package

veq.

Source

fxlspace.lisp.

Macro: op ((type out-dim mname args) &body body)

build an op. see ops-1.lisp, ops-2.lisp, ...

Package

veq.

Source

veq-ops.lisp.

Macro: ops (&body body)

used to build ops in ops-1.lisp, ops-2.lisp, ...

Package

veq.

Source

veq-ops.lisp.

Macro: pckgs ()
Package

veq.

Source

docs.lisp.

Macro: push* (v l)

push v to list l, and return v.

Package

veq.

Source

generic-utils.lisp.

Macro: struct-fields (dim type)
Package

veq.

Source

array-rows.lisp.

Macro: vverr-len (b wanted got)
Package

veq.

Source

ops-vv.lisp.

Macro: with-gensyms (syms &body body)
Package

veq.

Source

generic-utils.lisp.

Macro: with-struct ((name . fields) struct &body body)
Package

veq.

Source

generic-utils.lisp.


5.2.3 Ordinary functions

Function: $row (p i arr)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: %d$line (x/x-316 x/y-317)

init DVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %d$lspace (n a/x-10 b/x-11 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %d$point (x/x-205)

init DVEC array with 1 elements.

Package

veq.

Source

shapes.lisp.

Function: %d2$line (x/x-362 x/y-363 x/z-364 x/w-365)

init DVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %d2$lspace (n a/x-11 a/y-12 b/x-13 b/y-14 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %d2$point (x/x-239 x/y-240)

init DVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %d2mrot (a)

make 2d rotation matrix for rotating a rads

Package

veq.

Source

mat.lisp.

Function: %d2mrot* (a)

make 2d rotation matrix for rotating a rads

Package

veq.

Source

mat.lisp.

Function: %d2mscale (x/x-0 x/y-1)

make 2d matrix for scaling by x

Package

veq.

Source

mat.lisp.

Function: %d2mtrans (x/x-0 x/y-1)

make 2d transpose matrix for moving by x

Package

veq.

Source

mat.lisp.

Function: %d3$line (x/x-430 x/y-431 x/z-432 x/w-433 x/u-434 x/v-435)

init DVEC array with 6 elements.

Package

veq.

Source

shapes.lisp.

Function: %d3$lspace (n a/x-12 a/y-13 a/z-14 b/x-15 b/y-16 b/z-17 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %d3$point (x/x-285 x/y-286 x/z-287)

init DVEC array with 3 elements.

Package

veq.

Source

shapes.lisp.

Function: %d3mrot (a x y z)

make 3d rotation matrix for rotating a rad around unit vector (x y z)

Package

veq.

Source

mat.lisp.

Function: %d3mrot* (a x y z)

make 3d rotation matrix for rotating a rad around unit vector (x y z)

Package

veq.

Source

mat.lisp.

Function: %d3mscale (x/x-0 x/y-1 x/z-2)

make 3d matrix for scaling by x

Package

veq.

Source

mat.lisp.

Function: %d3mtrans (x/x-0 x/y-1 x/z-2)

make 3d transpose matrix for moving by x

Package

veq.

Source

mat.lisp.

Function: %d4$line (x/x-520 x/y-521 x/z-522 x/w-523 x/u-524 x/v-525 x/p-526 x/q-527)

init DVEC array with 8 elements.

Package

veq.

Source

shapes.lisp.

Function: %d4$lspace (n a/x-13 a/y-14 a/z-15 a/w-16 b/x-17 b/y-18 b/z-19 b/w-20 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %d4$point (x/x-342 x/y-343 x/z-344 x/w-345)

init DVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %f$line (x/x-0 x/y-1)

init FVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %f$lspace (n a/x-10 b/x-11 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %f$point (x/x-0)

init FVEC array with 1 elements.

Package

veq.

Source

shapes.lisp.

Function: %f2$line (x/x-46 x/y-47 x/z-48 x/w-49)

init FVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %f2$lspace (n a/x-11 a/y-12 b/x-13 b/y-14 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %f2$point (x/x-34 x/y-35)

init FVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %f2$rect (w h)
Package

veq.

Source

shapes.lisp.

Function: %f2in-bbox (top-left/x-0 top-left/y-1 bottom-right/x-2 bottom-right/y-3 pt/x-4 pt/y-5)
Package

veq.

Source

checks.lisp.

Function: %f2in-concave (shape pt/x-11 pt/y-12)
Package

veq.

Source

checks.lisp.

Function: %f2in-triangle (a/x-14 a/y-15 b/x-16 b/y-17 c/x-18 c/y-19 p/x-20 p/y-21)
Package

veq.

Source

checks.lisp.

Function: %f2lsegx (lines*)

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.

Package

veq.

Source

checks.lisp.

Function: %f2mrot (a)

make 2d rotation matrix for rotating a rads

Package

veq.

Source

mat.lisp.

Function: %f2mrot* (a)

make 2d rotation matrix for rotating a rads

Package

veq.

Source

mat.lisp.

Function: %f2mscale (x/x-0 x/y-1)

make 2d matrix for scaling by x

Package

veq.

Source

mat.lisp.

Function: %f2mtrans (x/x-0 x/y-1)

make 2d transpose matrix for moving by x

Package

veq.

Source

mat.lisp.

Function: %f2segdst (va/x-0 va/y-1 vb/x-2 vb/y-3 v/x-4 v/y-5)

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.

Package

veq.

Source

checks.lisp.

Function: %f2segx (a1/x-21 a1/y-22 a2/x-23 a2/y-24 b1/x-25 b1/y-26 b2/x-27 b2/y-28)

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

Package

veq.

Source

checks.lisp.

Function: %f3$line (x/x-114 x/y-115 x/z-116 x/w-117 x/u-118 x/v-119)

init FVEC array with 6 elements.

Package

veq.

Source

shapes.lisp.

Function: %f3$lspace (n a/x-12 a/y-13 a/z-14 b/x-15 b/y-16 b/z-17 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %f3$point (x/x-80 x/y-81 x/z-82)

init FVEC array with 3 elements.

Package

veq.

Source

shapes.lisp.

Function: %f3mrot (a x y z)

make 3d rotation matrix for rotating a rad around unit vector (x y z)

Package

veq.

Source

mat.lisp.

Function: %f3mrot* (a x y z)

make 3d rotation matrix for rotating a rad around unit vector (x y z)

Package

veq.

Source

mat.lisp.

Function: %f3mscale (x/x-0 x/y-1 x/z-2)

make 3d matrix for scaling by x

Package

veq.

Source

mat.lisp.

Function: %f3mtrans (x/x-0 x/y-1 x/z-2)

make 3d transpose matrix for moving by x

Package

veq.

Source

mat.lisp.

Function: %f3planex (n/x-14 n/y-15 n/z-16 p/x-17 p/y-18 p/z-19 a/x-20 a/y-21 a/z-22 b/x-23 b/y-24 b/z-25)

intersection of plane (n:normal, p:point) and line (a b)

Package

veq.

Source

checks.lisp.

Function: %f4$line (x/x-204 x/y-205 x/z-206 x/w-207 x/u-208 x/v-209 x/p-210 x/q-211)

init FVEC array with 8 elements.

Package

veq.

Source

shapes.lisp.

Function: %f4$lspace (n a/x-13 a/y-14 a/z-15 a/w-16 b/x-17 b/y-18 b/z-19 b/w-20 &key end)
Package

veq.

Source

fxlspace.lisp.

Function: %f4$point (x/x-137 x/y-138 x/z-139 x/w-140)

init FVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %fmake-ortho-proj-matrix (&optional w h n f)

make orthogonal projection matrix

Package

veq.

Source

mat-cam.lisp.

Function: %fmake-proj-matrix (&optional w h n f)

make projection matrix for width, height, near, far

Package

veq.

Source

mat-cam.lisp.

Function: %fmake-view-matrix (cam/x-7 cam/y-8 cam/z-9 target/x-10 target/y-11 target/z-12 up/x-13 up/y-14 up/z-15)

make view matrix for cam (w/up) looking at target

Package

veq.

Source

mat-cam.lisp.

Function: %i$line (x/x-632 x/y-633)

init IVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %i$point (x/x-410)

init IVEC array with 1 elements.

Package

veq.

Source

shapes.lisp.

Function: %i2$line (x/x-678 x/y-679 x/z-680 x/w-681)

init IVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %i2$point (x/x-444 x/y-445)

init IVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %i3$line (x/x-746 x/y-747 x/z-748 x/w-749 x/u-750 x/v-751)

init IVEC array with 6 elements.

Package

veq.

Source

shapes.lisp.

Function: %i3$point (x/x-490 x/y-491 x/z-492)

init IVEC array with 3 elements.

Package

veq.

Source

shapes.lisp.

Function: %i4$line (x/x-836 x/y-837 x/z-838 x/w-839 x/u-840 x/v-841 x/p-842 x/q-843)

init IVEC array with 8 elements.

Package

veq.

Source

shapes.lisp.

Function: %i4$point (x/x-547 x/y-548 x/z-549 x/w-550)

init IVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %p$line (x/x-948 x/y-949)

init PVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %p$point (x/x-615)

init PVEC array with 1 elements.

Package

veq.

Source

shapes.lisp.

Function: %p2$line (x/x-994 x/y-995 x/z-996 x/w-997)

init PVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: %p2$point (x/x-649 x/y-650)

init PVEC array with 2 elements.

Package

veq.

Source

shapes.lisp.

Function: %p3$line (x/x-1062 x/y-1063 x/z-1064 x/w-1065 x/u-1066 x/v-1067)

init PVEC array with 6 elements.

Package

veq.

Source

shapes.lisp.

Function: %p3$point (x/x-695 x/y-696 x/z-697)

init PVEC array with 3 elements.

Package

veq.

Source

shapes.lisp.

Function: %p4$line (x/x-1152 x/y-1153 x/z-1154 x/w-1155 x/u-1156 x/v-1157 x/p-1158 x/q-1159)

init PVEC array with 8 elements.

Package

veq.

Source

shapes.lisp.

Function: %p4$point (x/x-752 x/y-753 x/z-754 x/w-755)

init PVEC array with 4 elements.

Package

veq.

Source

shapes.lisp.

Function: -d2^ (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -d2angle (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2cross (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2dot (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2dst (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2dst2 (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2exp (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2flip (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2from (ax ay bx by s)
Package

veq.

Source

ops-2.lisp.

Function: -d2i- (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2i/ (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2id (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2iscale (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -d2len (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2len2 (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2lerp (ax ay bx by s)
Package

veq.

Source

ops-2.lisp.

Function: -d2max (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2mid (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -d2min (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2mod (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -d2norm (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2on-circ (ax rad)
Package

veq.

Source

ops-2.lisp.

Function: -d2on-circ* (ax rad)
Package

veq.

Source

ops-2.lisp.

Function: -d2perp (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2perp* (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2rot (ax ay angle)
Package

veq.

Source

ops-2.lisp.

Function: -d2rots (ax ay angle sx sy)
Package

veq.

Source

ops-2.lisp.

Function: -d2scale (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -d2sqrt (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d2square (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -d3^ (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -d3cross (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3dot (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3dst (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3dst2 (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3exp (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3from (ax ay az bx by bz s)
Package

veq.

Source

ops-3.lisp.

Function: -d3i- (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3i/ (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3id (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3iscale (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -d3len (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3len2 (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3lerp (ax ay az bx by bz s)
Package

veq.

Source

ops-3.lisp.

Function: -d3max (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3mid (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -d3min (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3mod (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -d3norm (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3rot (ax ay az nx ny nz a)
Package

veq.

Source

ops-3.lisp.

Function: -d3rots (ax ay az nx ny nz a sx sy sz)
Package

veq.

Source

ops-3.lisp.

Function: -d3scale (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -d3sqrt (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d3square (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -d4^ (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -d4dot (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -d4dst (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -d4dst2 (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -d4exp (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4from (ax ay az aw bx by bz bw s)
Package

veq.

Source

ops-4.lisp.

Function: -d4i- (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -d4i/ (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -d4id (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4iscale (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -d4len (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4len2 (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4lerp (ax ay az aw bx by bz bw s)
Package

veq.

Source

ops-4.lisp.

Function: -d4max (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4mid (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -d4min (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4mod (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -d4norm (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4scale (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -d4sqrt (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d4square (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -d^ (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -dclamp (x)
Package

veq.

Source

ops-1.lisp.

Function: -dclamp* (x mi ma)
Package

veq.

Source

ops-1.lisp.

Function: -dcos-sin (ax)
Package

veq.

Source

ops-1.lisp.

Function: -ddeg->rad (d)
Package

veq.

Source

ops-1.lisp.

Function: -dexp (ax)
Package

veq.

Source

ops-1.lisp.

Function: -dfrom (ax bx s)
Package

veq.

Source

ops-1.lisp.

Function: -di- (ax bx)
Package

veq.

Source

ops-1.lisp.

Function: -di/ (ax bx)
Package

veq.

Source

ops-1.lisp.

Function: -did (ax)
Package

veq.

Source

ops-1.lisp.

Function: -discale (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -dlen (ax)
Package

veq.

Source

ops-1.lisp.

Function: -dlen2 (ax)
Package

veq.

Source

ops-1.lisp.

Function: -dlerp (ax bx s)
Package

veq.

Source

ops-1.lisp.

Function: -dmid (ax bx)
Package

veq.

Source

ops-1.lisp.

Function: -dmod (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -dscale (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -dsin-cos (ax)
Package

veq.

Source

ops-1.lisp.

Function: -dsqrt (ax)
Package

veq.

Source

ops-1.lisp.

Function: -dsquare (ax)
Package

veq.

Source

ops-1.lisp.

Function: -expand-!symb (s)

t if symbol starts with Fd! where d is a positive integer

Package

veq.

Source

veq-ops.lisp.

Function: -expand-and-flatten-!symbols (ss)
Package

veq.

Source

veq-ops.lisp.

Function: -f2^ (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -f2angle (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2cross (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2dot (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2dst (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2dst2 (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2exp (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2flip (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2from (ax ay bx by s)
Package

veq.

Source

ops-2.lisp.

Function: -f2i- (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2i/ (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2id (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2iscale (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -f2len (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2len2 (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2lerp (ax ay bx by s)
Package

veq.

Source

ops-2.lisp.

Function: -f2max (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2mid (ax ay bx by)
Package

veq.

Source

ops-2.lisp.

Function: -f2min (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2mod (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -f2norm (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2on-circ (ax rad)
Package

veq.

Source

ops-2.lisp.

Function: -f2on-circ* (ax rad)
Package

veq.

Source

ops-2.lisp.

Function: -f2perp (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2perp* (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2rot (ax ay angle)
Package

veq.

Source

ops-2.lisp.

Function: -f2rots (ax ay angle sx sy)
Package

veq.

Source

ops-2.lisp.

Function: -f2scale (ax ay s)
Package

veq.

Source

ops-2.lisp.

Function: -f2sqrt (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f2square (ax ay)
Package

veq.

Source

ops-2.lisp.

Function: -f3^ (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -f3cross (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3dot (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3dst (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3dst2 (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3exp (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3from (ax ay az bx by bz s)
Package

veq.

Source

ops-3.lisp.

Function: -f3i- (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3i/ (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3id (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3iscale (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -f3len (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3len2 (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3lerp (ax ay az bx by bz s)
Package

veq.

Source

ops-3.lisp.

Function: -f3max (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3mid (ax ay az bx by bz)
Package

veq.

Source

ops-3.lisp.

Function: -f3min (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3mod (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -f3norm (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3rot (ax ay az nx ny nz a)
Package

veq.

Source

ops-3.lisp.

Function: -f3rots (ax ay az nx ny nz a sx sy sz)
Package

veq.

Source

ops-3.lisp.

Function: -f3scale (ax ay az s)
Package

veq.

Source

ops-3.lisp.

Function: -f3sqrt (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f3square (ax ay az)
Package

veq.

Source

ops-3.lisp.

Function: -f4^ (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -f4dot (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -f4dst (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -f4dst2 (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -f4exp (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4from (ax ay az aw bx by bz bw s)
Package

veq.

Source

ops-4.lisp.

Function: -f4i- (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -f4i/ (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -f4id (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4iscale (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -f4len (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4len2 (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4lerp (ax ay az aw bx by bz bw s)
Package

veq.

Source

ops-4.lisp.

Function: -f4max (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4mid (ax ay az aw bx by bz bw)
Package

veq.

Source

ops-4.lisp.

Function: -f4min (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4mod (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -f4norm (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4scale (ax ay az aw s)
Package

veq.

Source

ops-4.lisp.

Function: -f4sqrt (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f4square (ax ay az aw)
Package

veq.

Source

ops-4.lisp.

Function: -f^ (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -fclamp (x)
Package

veq.

Source

ops-1.lisp.

Function: -fclamp* (x mi ma)
Package

veq.

Source

ops-1.lisp.

Function: -fcos-sin (ax)
Package

veq.

Source

ops-1.lisp.

Function: -fdeg->rad (d)
Package

veq.

Source

ops-1.lisp.

Function: -fexp (ax)
Package

veq.

Source

ops-1.lisp.

Function: -ffrom (ax bx s)
Package

veq.

Source

ops-1.lisp.

Function: -fi- (ax bx)
Package

veq.

Source

ops-1.lisp.

Function: -fi/ (ax bx)
Package

veq.

Source

ops-1.lisp.

Function: -fid (ax)
Package

veq.

Source

ops-1.lisp.

Function: -fiscale (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -flen (ax)
Package

veq.

Source

ops-1.lisp.

Function: -flen2 (ax)
Package

veq.

Source

ops-1.lisp.

Function: -flerp (ax bx s)
Package

veq.

Source

ops-1.lisp.

Function: -fmid (ax bx)
Package

veq.

Source

ops-1.lisp.

Function: -fmod (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -fscale (ax s)
Package

veq.

Source

ops-1.lisp.

Function: -fsin-cos (ax)
Package

veq.

Source

ops-1.lisp.

Function: -fsqrt (ax)
Package

veq.

Source

ops-1.lisp.

Function: -fsquare (ax)
Package

veq.

Source

ops-1.lisp.

Function: -fxlspace (n a b fx &key dim type end)
Package

veq.

Source

fxlspace.lisp.

Function: -gensyms (name n)
Package

veq.

Source

generic-utils.lisp.

Function: -md-sanitize (d)
Package

veq.

Source

docs.lisp.

Function: -placeholders (root type)
Package

veq.

Source

veq-ops.lisp.

Function: -sorted-point-pairs (lines)
Package

veq.

Source

checks.lisp.

Function: -struct-fields (dim type s c slots)
Package

veq.

Source

array-rows.lisp.

Function: -sweep-line (lines line-points)

perform sweep line search for intersections along x

Package

veq.

Source

checks.lisp.

Function: -vlet (type dim all-args body)
Package

veq.

Source

lets.lisp.

Function: -vlet* (type all-args body)
Package

veq.

Source

lets.lisp.

Function: -vmvb (type dim arg expr body &key repvarg)

returns (mvb ((:va dim arg)) expr body)

Package

veq.

Source

lets.lisp.

Function: -vmvb* (type dim arg expr body)
Package

veq.

Source

lets.lisp.

Function: -wrapnum (n)
Package

veq.

Source

fxlspace.lisp.

Function: ?@-index-type (o)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: ?@-loop-type (o)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: at-most (n &rest rest)
Package

veq.

Source

generic-utils.lisp.

Function: body-len (n a)
Package

veq.

Source

veq-ops.lisp.

Function: car-match-modifier (mod b)

returns (values prefix-ind prefix opt/d b). eg: 1 x (0) arr

Package

veq.

Source

ops-vv-helpers.lisp.

Function: desc (sym)
Package

veq.

Source

docs.lisp.

Function: dim? (a dim &key type)
Package

veq.

Source

lets.lisp.

Function: docstrings (sym)
Package

veq.

Source

docs.lisp.

Function: dotted-listp (l)
Package

veq.

Source

generic-utils.lisp.

Function: dupes (lst)

finds duplicates in list.

Package

veq.

Source

generic-utils.lisp.

Function: edge-fx (fx s &optional rht)

count number of times fx is t across sym chars from the left (or right) returns (values c sym*), where sym* is sym with the padding characters removed

Package

veq.

Source

generic-utils.lisp.

Function: edge-str (ch s &optional rht)

count number of padding characters ch in s from the left (or right) returns (values c sym*), where sym* is s with the padding characters removed

Package

veq.

Source

generic-utils.lisp.

Function: filter-macrolets (symbols-map body)

remove macrolet tuples that are not present in body. this speeds up compilation time considerably, and makes it easier to read output code.

note: it can cause errors in in cases with nested macros.

Package

veq.

Source

macros-helpers.lisp.

Function: find-all-relevant-symbols (body)
Package

veq.

Source

macros-helpers.lisp.

Function: flatten (x)
Package

veq.

Source

generic-utils.lisp.

Function: fx-split-str (fx s)

split s into list of chars according to fx

Package

veq.

Source

generic-utils.lisp.

Function: fx-strip (fx pkg)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: fx@conf (p b)
Package

veq.

Source

ops-vv.lisp.

Function: get-docs (body)

find docstring for body

Package

veq.

Source

macrolets.lisp.

Function: gk (p k &optional silent)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: gk+ (p &rest keys)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: gk0 (p &rest keys)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: group (source n)
Package

veq.

Source

generic-utils.lisp.

Function: last* (l)
Package

veq.

Source

generic-utils.lisp.

Function: lconf (p b)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: lpos (l &optional i j)
Package

veq.

Source

generic-utils.lisp.

Function: lst>n (l n)

is list longer than n?

Package

veq.

Source

generic-utils.lisp.

Function: make-wrap-docs (context fname body)
Package

veq.

Source

macrolets.lisp.

Function: map-docstring (&rest rest)

register docs info associated with symbol (car rest). internal.

Package

veq.

Source

docs.lisp.

Function: map-symbol (pair)

add pair macrolet pair. see macro.lisp.

Package

veq.

Source

veq-ops.lisp.

Function: mapqt (l)
Package

veq.

Source

generic-utils.lisp.

Function: match-substr (sub s)

returns index where substring matches s from left to right. otherwise nil.

Package

veq.

Source

generic-utils.lisp.

Function: mkstr (&rest args)
Package

veq.

Source

generic-utils.lisp.

Function: niloutconf (p b)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: nilpad (n l &optional v)

cons v to l intil (length l) >= n

Package

veq.

Source

generic-utils.lisp.

Function: nth* (l i &optional d)
Package

veq.

Source

generic-utils.lisp.

Function: nvrs (a c n)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: optype (symb)

use first letter to select type d -> df, f -> ff.

Package

veq.

Source

veq-ops.lisp.

Function: proc!@$fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc!@$fx$ (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc!@$fx. (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc!@.fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc!@fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc!@fx. (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc%@$fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc%@fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc.@$fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc.@fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc_@$fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc_@$fx. (b p)
Package

veq.

Source

ops-vv.lisp.

Function: proc_@fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: procf@fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: procm@fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: procr@$fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: procx@$fx (b p)
Package

veq.

Source

ops-vv.lisp.

Function: psymb (pkg &rest args)
Package

veq.

Source

generic-utils.lisp.

Function: rconf (p b)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: reread (&rest args)
Package

veq.

Source

generic-utils.lisp.

Function: select-docs (sym)
Package

veq.

Source

docs.lisp.

Function: split-string (x s &key prune)
Package

veq.

Source

generic-utils.lisp.

Function: split-substr (x s &key prune)
Package

veq.

Source

generic-utils.lisp.

Function: strcat (s)
Package

veq.

Source

generic-utils.lisp.

Function: strip-symbols (name symbs)
Package

veq.

Source

generic-utils.lisp.

Function: symb (&rest args)
Package

veq.

Source

generic-utils.lisp.

Function: tailconf (p b)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: undup (e &optional flatten)
Package

veq.

Source

generic-utils.lisp.

Function: vec-select-itr (p)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: vgetenv (name &optional default)
Package

veq.

Source

init.lisp.

Function: vv-proc (body)
Package

veq.

Source

ops-vv.lisp.

Function: vvconf (b vv-sym)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: vverr (expr msg)
Package

veq.

Source

ops-vv-helpers.lisp.

Function: xlet-proc (all-vars &rest body)
Package

veq.

Source

lets.lisp.


5.2.4 Types

Type: array-fvec ()
Package

veq.

Source

checks.lisp.


Appendix A Indexes


A.1 Concepts


A.2 Functions

Jump to:   $   %   (   -   2   3   4   ?   ~  
A   B   C   D   E   F   G   I   K   L   M   N   O   P   R   S   T   U   V   W   X  
Index Entry  Section

$
$make: Public macros
$num: Public ordinary functions
$nvset: Public macros
$print: Public ordinary functions
$row: Private ordinary functions
$to-list: Public ordinary functions

%
%d$line: Private ordinary functions
%d$lspace: Private ordinary functions
%d$point: Private ordinary functions
%d2$line: Private ordinary functions
%d2$lspace: Private ordinary functions
%d2$point: Private ordinary functions
%d2mrot: Private ordinary functions
%d2mrot*: Private ordinary functions
%d2mscale: Private ordinary functions
%d2mtrans: Private ordinary functions
%d3$line: Private ordinary functions
%d3$lspace: Private ordinary functions
%d3$point: Private ordinary functions
%d3mrot: Private ordinary functions
%d3mrot*: Private ordinary functions
%d3mscale: Private ordinary functions
%d3mtrans: Private ordinary functions
%d4$line: Private ordinary functions
%d4$lspace: Private ordinary functions
%d4$point: Private ordinary functions
%f$line: Private ordinary functions
%f$lspace: Private ordinary functions
%f$point: Private ordinary functions
%f2$line: Private ordinary functions
%f2$lspace: Private ordinary functions
%f2$point: Private ordinary functions
%f2$rect: Private ordinary functions
%f2in-bbox: Private ordinary functions
%f2in-concave: Private ordinary functions
%f2in-triangle: Private ordinary functions
%f2lsegx: Private ordinary functions
%f2mrot: Private ordinary functions
%f2mrot*: Private ordinary functions
%f2mscale: Private ordinary functions
%f2mtrans: Private ordinary functions
%f2segdst: Private ordinary functions
%f2segx: Private ordinary functions
%f3$line: Private ordinary functions
%f3$lspace: Private ordinary functions
%f3$point: Private ordinary functions
%f3mrot: Private ordinary functions
%f3mrot*: Private ordinary functions
%f3mscale: Private ordinary functions
%f3mtrans: Private ordinary functions
%f3planex: Private ordinary functions
%f4$line: Private ordinary functions
%f4$lspace: Private ordinary functions
%f4$point: Private ordinary functions
%fmake-ortho-proj-matrix: Private ordinary functions
%fmake-proj-matrix: Private ordinary functions
%fmake-view-matrix: Private ordinary functions
%i$line: Private ordinary functions
%i$point: Private ordinary functions
%i2$line: Private ordinary functions
%i2$point: Private ordinary functions
%i3$line: Private ordinary functions
%i3$point: Private ordinary functions
%i4$line: Private ordinary functions
%i4$point: Private ordinary functions
%p$line: Private ordinary functions
%p$point: Private ordinary functions
%p2$line: Private ordinary functions
%p2$point: Private ordinary functions
%p3$line: Private ordinary functions
%p3$point: Private ordinary functions
%p4$line: Private ordinary functions
%p4$point: Private ordinary functions

(
(setf $): Public setf expanders
(setf 2$): Public setf expanders
(setf 3$): Public setf expanders
(setf 4$): Public setf expanders

-
-$: Private macros
-d2angle: Private ordinary functions
-d2cross: Private ordinary functions
-d2dot: Private ordinary functions
-d2dst: Private ordinary functions
-d2dst2: Private ordinary functions
-d2exp: Private ordinary functions
-d2flip: Private ordinary functions
-d2from: Private ordinary functions
-d2i-: Private ordinary functions
-d2i/: Private ordinary functions
-d2id: Private ordinary functions
-d2iscale: Private ordinary functions
-d2len: Private ordinary functions
-d2len2: Private ordinary functions
-d2lerp: Private ordinary functions
-d2max: Private ordinary functions
-d2mid: Private ordinary functions
-d2min: Private ordinary functions
-d2mod: Private ordinary functions
-d2norm: Private ordinary functions
-d2on-circ: Private ordinary functions
-d2on-circ*: Private ordinary functions
-d2perp: Private ordinary functions
-d2perp*: Private ordinary functions
-d2rot: Private ordinary functions
-d2rots: Private ordinary functions
-d2scale: Private ordinary functions
-d2sqrt: Private ordinary functions
-d2square: Private ordinary functions
-d2^: Private ordinary functions
-d3cross: Private ordinary functions
-d3dot: Private ordinary functions
-d3dst: Private ordinary functions
-d3dst2: Private ordinary functions
-d3exp: Private ordinary functions
-d3from: Private ordinary functions
-d3i-: Private ordinary functions
-d3i/: Private ordinary functions
-d3id: Private ordinary functions
-d3iscale: Private ordinary functions
-d3len: Private ordinary functions
-d3len2: Private ordinary functions
-d3lerp: Private ordinary functions
-d3max: Private ordinary functions
-d3mid: Private ordinary functions
-d3min: Private ordinary functions
-d3mod: Private ordinary functions
-d3norm: Private ordinary functions
-d3rot: Private ordinary functions
-d3rots: Private ordinary functions
-d3scale: Private ordinary functions
-d3sqrt: Private ordinary functions
-d3square: Private ordinary functions
-d3^: Private ordinary functions
-d4dot: Private ordinary functions
-d4dst: Private ordinary functions
-d4dst2: Private ordinary functions
-d4exp: Private ordinary functions
-d4from: Private ordinary functions
-d4i-: Private ordinary functions
-d4i/: Private ordinary functions
-d4id: Private ordinary functions
-d4iscale: Private ordinary functions
-d4len: Private ordinary functions
-d4len2: Private ordinary functions
-d4lerp: Private ordinary functions
-d4max: Private ordinary functions
-d4mid: Private ordinary functions
-d4min: Private ordinary functions
-d4mod: Private ordinary functions
-d4norm: Private ordinary functions
-d4scale: Private ordinary functions
-d4sqrt: Private ordinary functions
-d4square: Private ordinary functions
-d4^: Private ordinary functions
-dclamp: Private ordinary functions
-dclamp*: Private ordinary functions
-dcos-sin: Private ordinary functions
-ddeg->rad: Private ordinary functions
-dexp: Private ordinary functions
-dfrom: Private ordinary functions
-di-: Private ordinary functions
-di/: Private ordinary functions
-did: Private ordinary functions
-discale: Private ordinary functions
-dlen: Private ordinary functions
-dlen2: Private ordinary functions
-dlerp: Private ordinary functions
-dmid: Private ordinary functions
-dmod: Private ordinary functions
-dscale: Private ordinary functions
-dsin-cos: Private ordinary functions
-dsqrt: Private ordinary functions
-dsquare: Private ordinary functions
-d^: Private ordinary functions
-expand-!symb: Private ordinary functions
-expand-and-flatten-!symbols: Private ordinary functions
-f2angle: Private ordinary functions
-f2cross: Private ordinary functions
-f2dot: Private ordinary functions
-f2dst: Private ordinary functions
-f2dst2: Private ordinary functions
-f2exp: Private ordinary functions
-f2flip: Private ordinary functions
-f2from: Private ordinary functions
-f2i-: Private ordinary functions
-f2i/: Private ordinary functions
-f2id: Private ordinary functions
-f2iscale: Private ordinary functions
-f2len: Private ordinary functions
-f2len2: Private ordinary functions
-f2lerp: Private ordinary functions
-f2max: Private ordinary functions
-f2mid: Private ordinary functions
-f2min: Private ordinary functions
-f2mod: Private ordinary functions
-f2norm: Private ordinary functions
-f2on-circ: Private ordinary functions
-f2on-circ*: Private ordinary functions
-f2perp: Private ordinary functions
-f2perp*: Private ordinary functions
-f2rot: Private ordinary functions
-f2rots: Private ordinary functions
-f2scale: Private ordinary functions
-f2sqrt: Private ordinary functions
-f2square: Private ordinary functions
-f2^: Private ordinary functions
-f3cross: Private ordinary functions
-f3dot: Private ordinary functions
-f3dst: Private ordinary functions
-f3dst2: Private ordinary functions
-f3exp: Private ordinary functions
-f3from: Private ordinary functions
-f3i-: Private ordinary functions
-f3i/: Private ordinary functions
-f3id: Private ordinary functions
-f3iscale: Private ordinary functions
-f3len: Private ordinary functions
-f3len2: Private ordinary functions
-f3lerp: Private ordinary functions
-f3max: Private ordinary functions
-f3mid: Private ordinary functions
-f3min: Private ordinary functions
-f3mod: Private ordinary functions
-f3norm: Private ordinary functions
-f3rot: Private ordinary functions
-f3rots: Private ordinary functions
-f3scale: Private ordinary functions
-f3sqrt: Private ordinary functions
-f3square: Private ordinary functions
-f3^: Private ordinary functions
-f4dot: Private ordinary functions
-f4dst: Private ordinary functions
-f4dst2: Private ordinary functions
-f4exp: Private ordinary functions
-f4from: Private ordinary functions
-f4i-: Private ordinary functions
-f4i/: Private ordinary functions
-f4id: Private ordinary functions
-f4iscale: Private ordinary functions
-f4len: Private ordinary functions
-f4len2: Private ordinary functions
-f4lerp: Private ordinary functions
-f4max: Private ordinary functions
-f4mid: Private ordinary functions
-f4min: Private ordinary functions
-f4mod: Private ordinary functions
-f4norm: Private ordinary functions
-f4scale: Private ordinary functions
-f4sqrt: Private ordinary functions
-f4square: Private ordinary functions
-f4^: Private ordinary functions
-fclamp: Private ordinary functions
-fclamp*: Private ordinary functions
-fcos-sin: Private ordinary functions
-fdeg->rad: Private ordinary functions
-fexp: Private ordinary functions
-ffrom: Private ordinary functions
-fi-: Private ordinary functions
-fi/: Private ordinary functions
-fid: Private ordinary functions
-fiscale: Private ordinary functions
-flen: Private ordinary functions
-flen2: Private ordinary functions
-flerp: Private ordinary functions
-fmid: Private ordinary functions
-fmod: Private ordinary functions
-fscale: Private ordinary functions
-fsin-cos: Private ordinary functions
-fsqrt: Private ordinary functions
-fsquare: Private ordinary functions
-fxlspace: Private ordinary functions
-f^: Private ordinary functions
-gensyms: Private ordinary functions
-lspace: Private macros
-md-sanitize: Private ordinary functions
-placeholders: Private ordinary functions
-sorted-point-pairs: Private ordinary functions
-struct-fields: Private ordinary functions
-sweep-line: Private ordinary functions
-vlet: Private ordinary functions
-vlet*: Private ordinary functions
-vmvb: Private ordinary functions
-vmvb*: Private ordinary functions
-wrapnum: Private ordinary functions
-xmima: Private macros

2
2$num: Public ordinary functions
2$print: Public ordinary functions
2$to-list: Public ordinary functions

3
3$num: Public ordinary functions
3$print: Public ordinary functions
3$to-list: Public ordinary functions

4
4$num: Public ordinary functions
4$print: Public ordinary functions
4$to-list: Public ordinary functions

?
?@-index-type: Private ordinary functions
?@-loop-type: Private ordinary functions

~
~: Public macros

A
abbrev: Private macros
aif: Private macros
arrtype: Public ordinary functions
at-most: Private ordinary functions
awf: Private macros
awg: Private macros

B
body-len: Private ordinary functions

C
car-match-modifier: Private ordinary functions
context?: Public macros

D
d$: Public macros
d$copy: Public ordinary functions
d$last: Public ordinary functions
d$line: Public macros
d$lspace: Public macros
d$make: Public macros
d$mima: Public ordinary functions
d$num: Public ordinary functions
d$one: Public ordinary functions
d$point: Public macros
d$val: Public ordinary functions
d$zero: Public ordinary functions
d$_: Public ordinary functions
d$~: Public macros
d2$: Public macros
d2$last: Public ordinary functions
d2$line: Public macros
d2$lspace: Public macros
d2$mima: Public ordinary functions
d2$num: Public ordinary functions
d2$one: Public ordinary functions
d2$point: Public macros
d2$val: Public ordinary functions
d2$zero: Public ordinary functions
d2meye: Public ordinary functions
d2minv: Public ordinary functions
d2mm: Public macros
d2mmt: Public macros
d2mrot: Public macros
d2mrot*: Public macros
d2mscale: Public macros
d2mt!: Public macros
d2mtm: Public macros
d2mtmt: Public macros
d2mtrans: Public macros
d2mtv: Public macros
d2mv: Public macros
d3$: Public macros
d3$last: Public ordinary functions
d3$line: Public macros
d3$lspace: Public macros
d3$mima: Public ordinary functions
d3$num: Public ordinary functions
d3$one: Public ordinary functions
d3$point: Public macros
d3$val: Public ordinary functions
d3$zero: Public ordinary functions
d3meye: Public ordinary functions
d3minv: Public ordinary functions
d3mm: Public macros
d3mmt: Public macros
d3mrot: Public macros
d3mrot*: Public macros
d3mscale: Public macros
d3mt!: Public macros
d3mtm: Public macros
d3mtmt: Public macros
d3mtrans: Public macros
d3mtv: Public macros
d3mv: Public macros
d4$: Public macros
d4$last: Public ordinary functions
d4$line: Public macros
d4$lspace: Public macros
d4$num: Public ordinary functions
d4$one: Public ordinary functions
d4$point: Public macros
d4$val: Public ordinary functions
d4$zero: Public ordinary functions
d4meye: Public ordinary functions
d4minv: Public ordinary functions
d4mm: Public macros
d4mmt: Public macros
d4mt!: Public macros
d4mtm: Public macros
d4mtmt: Public macros
d4mtv: Public macros
d4mv: Public macros
d?: Public ordinary functions
dease-in-back: Public ordinary functions
dease-in-circ: Public ordinary functions
dease-in-cubic: Public ordinary functions
dease-in-elastic: Public ordinary functions
dease-in-exp: Public ordinary functions
dease-in-linear: Public ordinary functions
dease-in-out-back: Public ordinary functions
dease-in-out-circ: Public ordinary functions
dease-in-out-cubic: Public ordinary functions
dease-in-out-elastic: Public ordinary functions
dease-in-out-exp: Public ordinary functions
dease-in-out-linear: Public ordinary functions
dease-in-out-quart: Public ordinary functions
dease-in-out-quint: Public ordinary functions
dease-in-out-sin: Public ordinary functions
dease-in-quart: Public ordinary functions
dease-in-quint: Public ordinary functions
dease-in-sin: Public ordinary functions
dease-out-back: Public ordinary functions
dease-out-circ: Public ordinary functions
dease-out-cubic: Public ordinary functions
dease-out-elastic: Public ordinary functions
dease-out-exp: Public ordinary functions
dease-out-linear: Public ordinary functions
dease-out-quart: Public ordinary functions
dease-out-quint: Public ordinary functions
dease-out-sin: Public ordinary functions
def*: Public macros
define-$: Private macros
define-arr-num: Private macros
define-arr-shape: Private macros
define-arr-util: Private macros
define-constants: Private macros
define-constr: Private macros
define-creators: Private macros
define-def*: Private macros
define-fvdef: Private macros
define-fvdef*: Private macros
define-fvprogn: Private macros
define-rep: Private macros
define-td: Private macros
define-td~: Private macros
define-val: Private macros
define-vdef: Private macros
define-vdef*: Private macros
define-vlet: Private macros
define-vprogn: Private macros
define-vsel: Private macros
define-vv-macro: Private macros
define-xlet-macro: Private macros
desc: Private ordinary functions
df: Public ordinary functions
df*: Public macros
dfl: Public ordinary functions
dim?: Private ordinary functions
docstrings: Private ordinary functions
dotted-listp: Private ordinary functions
dsb: Public macros
dsel: Public macros
dupes: Private ordinary functions
d_: Public macros

E
easing-op: Private macros
edge-fx: Private ordinary functions
edge-str: Private ordinary functions
ext-symbols?: Public macros

F
f$: Public macros
f$copy: Public ordinary functions
f$last: Public ordinary functions
f$line: Public macros
f$lspace: Public macros
f$make: Public macros
f$mima: Public ordinary functions
f$num: Public ordinary functions
f$one: Public ordinary functions
f$point: Public macros
f$val: Public ordinary functions
f$zero: Public ordinary functions
f$_: Public ordinary functions
f$~: Public macros
f2$: Public macros
f2$center: Public ordinary functions
f2$circ: Public ordinary functions
f2$last: Public ordinary functions
f2$line: Public macros
f2$lspace: Public macros
f2$mima: Public ordinary functions
f2$num: Public ordinary functions
f2$one: Public ordinary functions
f2$point: Public macros
f2$polygon: Public ordinary functions
f2$rect: Public macros
f2$square*: Public ordinary functions
f2$val: Public ordinary functions
f2$zero: Public ordinary functions
f2in-bbox: Public macros
f2in-concave: Public macros
f2in-triangle: Public macros
f2lsegx: Public macros
f2meye: Public ordinary functions
f2minv: Public ordinary functions
f2mm: Public macros
f2mmt: Public macros
f2mrot: Public macros
f2mrot*: Public macros
f2mscale: Public macros
f2mt!: Public macros
f2mtm: Public macros
f2mtmt: Public macros
f2mtrans: Public macros
f2mtv: Public macros
f2mv: Public macros
f2segdst: Public macros
f2segx: Public macros
f3$: Public macros
f3$last: Public ordinary functions
f3$line: Public macros
f3$lspace: Public macros
f3$mima: Public ordinary functions
f3$num: Public ordinary functions
f3$one: Public ordinary functions
f3$point: Public macros
f3$val: Public ordinary functions
f3$zero: Public ordinary functions
f3meye: Public ordinary functions
f3minv: Public ordinary functions
f3mm: Public macros
f3mmt: Public macros
f3mrot: Public macros
f3mrot*: Public macros
f3mscale: Public macros
f3mt!: Public macros
f3mtm: Public macros
f3mtmt: Public macros
f3mtrans: Public macros
f3mtv: Public macros
f3mv: Public macros
f3planex: Public macros
f4$: Public macros
f4$last: Public ordinary functions
f4$line: Public macros
f4$lspace: Public macros
f4$num: Public ordinary functions
f4$one: Public ordinary functions
f4$point: Public macros
f4$val: Public ordinary functions
f4$zero: Public ordinary functions
f4meye: Public ordinary functions
f4minv: Public ordinary functions
f4mm: Public macros
f4mmt: Public macros
f4mt!: Public macros
f4mtm: Public macros
f4mtmt: Public macros
f4mtv: Public macros
f4mv: Public macros
fease-in-back: Public ordinary functions
fease-in-circ: Public ordinary functions
fease-in-cubic: Public ordinary functions
fease-in-elastic: Public ordinary functions
fease-in-exp: Public ordinary functions
fease-in-linear: Public ordinary functions
fease-in-out-back: Public ordinary functions
fease-in-out-circ: Public ordinary functions
fease-in-out-cubic: Public ordinary functions
fease-in-out-elastic: Public ordinary functions
fease-in-out-exp: Public ordinary functions
fease-in-out-linear: Public ordinary functions
fease-in-out-quart: Public ordinary functions
fease-in-out-quint: Public ordinary functions
fease-in-out-sin: Public ordinary functions
fease-in-quart: Public ordinary functions
fease-in-quint: Public ordinary functions
fease-in-sin: Public ordinary functions
fease-out-back: Public ordinary functions
fease-out-circ: Public ordinary functions
fease-out-cubic: Public ordinary functions
fease-out-elastic: Public ordinary functions
fease-out-exp: Public ordinary functions
fease-out-linear: Public ordinary functions
fease-out-quart: Public ordinary functions
fease-out-quint: Public ordinary functions
fease-out-sin: Public ordinary functions
ff: Public ordinary functions
ff*: Public macros
ffl: Public ordinary functions
filter-macrolets: Private ordinary functions
find-all-relevant-symbols: Private ordinary functions
flatten: Private ordinary functions
fmake-ortho-proj-matrix: Public macros
fmake-proj-matrix: Public macros
fmake-view-matrix: Public macros
from-lst: Public macros
fsel: Public macros
Function, $num: Public ordinary functions
Function, $print: Public ordinary functions
Function, $row: Private ordinary functions
Function, $to-list: Public ordinary functions
Function, %d$line: Private ordinary functions
Function, %d$lspace: Private ordinary functions
Function, %d$point: Private ordinary functions
Function, %d2$line: Private ordinary functions
Function, %d2$lspace: Private ordinary functions
Function, %d2$point: Private ordinary functions
Function, %d2mrot: Private ordinary functions
Function, %d2mrot*: Private ordinary functions
Function, %d2mscale: Private ordinary functions
Function, %d2mtrans: Private ordinary functions
Function, %d3$line: Private ordinary functions
Function, %d3$lspace: Private ordinary functions
Function, %d3$point: Private ordinary functions
Function, %d3mrot: Private ordinary functions
Function, %d3mrot*: Private ordinary functions
Function, %d3mscale: Private ordinary functions
Function, %d3mtrans: Private ordinary functions
Function, %d4$line: Private ordinary functions
Function, %d4$lspace: Private ordinary functions
Function, %d4$point: Private ordinary functions
Function, %f$line: Private ordinary functions
Function, %f$lspace: Private ordinary functions
Function, %f$point: Private ordinary functions
Function, %f2$line: Private ordinary functions
Function, %f2$lspace: Private ordinary functions
Function, %f2$point: Private ordinary functions
Function, %f2$rect: Private ordinary functions
Function, %f2in-bbox: Private ordinary functions
Function, %f2in-concave: Private ordinary functions
Function, %f2in-triangle: Private ordinary functions
Function, %f2lsegx: Private ordinary functions
Function, %f2mrot: Private ordinary functions
Function, %f2mrot*: Private ordinary functions
Function, %f2mscale: Private ordinary functions
Function, %f2mtrans: Private ordinary functions
Function, %f2segdst: Private ordinary functions
Function, %f2segx: Private ordinary functions
Function, %f3$line: Private ordinary functions
Function, %f3$lspace: Private ordinary functions
Function, %f3$point: Private ordinary functions
Function, %f3mrot: Private ordinary functions
Function, %f3mrot*: Private ordinary functions
Function, %f3mscale: Private ordinary functions
Function, %f3mtrans: Private ordinary functions
Function, %f3planex: Private ordinary functions
Function, %f4$line: Private ordinary functions
Function, %f4$lspace: Private ordinary functions
Function, %f4$point: Private ordinary functions
Function, %fmake-ortho-proj-matrix: Private ordinary functions
Function, %fmake-proj-matrix: Private ordinary functions
Function, %fmake-view-matrix: Private ordinary functions
Function, %i$line: Private ordinary functions
Function, %i$point: Private ordinary functions
Function, %i2$line: Private ordinary functions
Function, %i2$point: Private ordinary functions
Function, %i3$line: Private ordinary functions
Function, %i3$point: Private ordinary functions
Function, %i4$line: Private ordinary functions
Function, %i4$point: Private ordinary functions
Function, %p$line: Private ordinary functions
Function, %p$point: Private ordinary functions
Function, %p2$line: Private ordinary functions
Function, %p2$point: Private ordinary functions
Function, %p3$line: Private ordinary functions
Function, %p3$point: Private ordinary functions
Function, %p4$line: Private ordinary functions
Function, %p4$point: Private ordinary functions
Function, -d2angle: Private ordinary functions
Function, -d2cross: Private ordinary functions
Function, -d2dot: Private ordinary functions
Function, -d2dst: Private ordinary functions
Function, -d2dst2: Private ordinary functions
Function, -d2exp: Private ordinary functions
Function, -d2flip: Private ordinary functions
Function, -d2from: Private ordinary functions
Function, -d2i-: Private ordinary functions
Function, -d2i/: Private ordinary functions
Function, -d2id: Private ordinary functions
Function, -d2iscale: Private ordinary functions
Function, -d2len: Private ordinary functions
Function, -d2len2: Private ordinary functions
Function, -d2lerp: Private ordinary functions
Function, -d2max: Private ordinary functions
Function, -d2mid: Private ordinary functions
Function, -d2min: Private ordinary functions
Function, -d2mod: Private ordinary functions
Function, -d2norm: Private ordinary functions
Function, -d2on-circ: Private ordinary functions
Function, -d2on-circ*: Private ordinary functions
Function, -d2perp: Private ordinary functions
Function, -d2perp*: Private ordinary functions
Function, -d2rot: Private ordinary functions
Function, -d2rots: Private ordinary functions
Function, -d2scale: Private ordinary functions
Function, -d2sqrt: Private ordinary functions
Function, -d2square: Private ordinary functions
Function, -d2^: Private ordinary functions
Function, -d3cross: Private ordinary functions
Function, -d3dot: Private ordinary functions
Function, -d3dst: Private ordinary functions
Function, -d3dst2: Private ordinary functions
Function, -d3exp: Private ordinary functions
Function, -d3from: Private ordinary functions
Function, -d3i-: Private ordinary functions
Function, -d3i/: Private ordinary functions
Function, -d3id: Private ordinary functions
Function, -d3iscale: Private ordinary functions
Function, -d3len: Private ordinary functions
Function, -d3len2: Private ordinary functions
Function, -d3lerp: Private ordinary functions
Function, -d3max: Private ordinary functions
Function, -d3mid: Private ordinary functions
Function, -d3min: Private ordinary functions
Function, -d3mod: Private ordinary functions
Function, -d3norm: Private ordinary functions
Function, -d3rot: Private ordinary functions
Function, -d3rots: Private ordinary functions
Function, -d3scale: Private ordinary functions
Function, -d3sqrt: Private ordinary functions
Function, -d3square: Private ordinary functions
Function, -d3^: Private ordinary functions
Function, -d4dot: Private ordinary functions
Function, -d4dst: Private ordinary functions
Function, -d4dst2: Private ordinary functions
Function, -d4exp: Private ordinary functions
Function, -d4from: Private ordinary functions
Function, -d4i-: Private ordinary functions
Function, -d4i/: Private ordinary functions
Function, -d4id: Private ordinary functions
Function, -d4iscale: Private ordinary functions
Function, -d4len: Private ordinary functions
Function, -d4len2: Private ordinary functions
Function, -d4lerp: Private ordinary functions
Function, -d4max: Private ordinary functions
Function, -d4mid: Private ordinary functions
Function, -d4min: Private ordinary functions
Function, -d4mod: Private ordinary functions
Function, -d4norm: Private ordinary functions
Function, -d4scale: Private ordinary functions
Function, -d4sqrt: Private ordinary functions
Function, -d4square: Private ordinary functions
Function, -d4^: Private ordinary functions
Function, -dclamp: Private ordinary functions
Function, -dclamp*: Private ordinary functions
Function, -dcos-sin: Private ordinary functions
Function, -ddeg->rad: Private ordinary functions
Function, -dexp: Private ordinary functions
Function, -dfrom: Private ordinary functions
Function, -di-: Private ordinary functions
Function, -di/: Private ordinary functions
Function, -did: Private ordinary functions
Function, -discale: Private ordinary functions
Function, -dlen: Private ordinary functions
Function, -dlen2: Private ordinary functions
Function, -dlerp: Private ordinary functions
Function, -dmid: Private ordinary functions
Function, -dmod: Private ordinary functions
Function, -dscale: Private ordinary functions
Function, -dsin-cos: Private ordinary functions
Function, -dsqrt: Private ordinary functions
Function, -dsquare: Private ordinary functions
Function, -d^: Private ordinary functions
Function, -expand-!symb: Private ordinary functions
Function, -expand-and-flatten-!symbols: Private ordinary functions
Function, -f2angle: Private ordinary functions
Function, -f2cross: Private ordinary functions
Function, -f2dot: Private ordinary functions
Function, -f2dst: Private ordinary functions
Function, -f2dst2: Private ordinary functions
Function, -f2exp: Private ordinary functions
Function, -f2flip: Private ordinary functions
Function, -f2from: Private ordinary functions
Function, -f2i-: Private ordinary functions
Function, -f2i/: Private ordinary function