The veq Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The veq Reference Manual

This is the veq Reference Manual, version 2.2.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 04:16:02 2022 GMT+0.

Table of Contents


1 Introduction

VEQ

VEQ is a set of convenience utilities for writing (1d/)2d/3d vector mathematics. It suports single vectors or arrays of vectors, with some broadcasting and reduction operations.

VEQ was written to be the vector library used in my generative art library weird.

Examples and Documentation

Here are some examples of use:

(in-package :veq)

(vprogn
  ; single vectors
  (f2let ((a (f2 1f0 2f0))
          (b (f2 3f0 100f0)))
    ; prints the euclidian length of 2d vector (a+b)*0.1
    (print (f2len (f2scale (f2+ a b) 0.1f0))))

  ; arrays of vectors
  (let ((a (f2$point 3f0 3f0))
        (line (f2$line 3f0 40f0 7f0 3f0))
        (line* (f2$line 1f0 2f0 3f0 4f0))
        (b (f$_ (loop for v from 0 below 6
                            collect (list (ff v) (ff (1+ v)))))))

    ; convenience function to print arrays of vectors:
    (vpr (2$print line)) ; returns a

    (vpr (f2. (f2$ a 0) (f2$ line 1))) ; dot product
    ;> 30.0

    (vpr (f2cross (f2$ line 0 1))) ; cross product
    ;> -271.0
    ; equivalent to:
    (vpr (f2cross (f2$ line 0) (f2$ line 1)))

    (vpr (f2$+ (f2$zero 3) 3f0 1f0)
         #(3f0 1f0 3f0 1f0 3f0 1f0))

    (vpr (f2$len (f2$+ (f2$zero 3) 3f0 1f0))
        #(3.1622777 3.1622777 3.1622777))

    (vpr (f2$+ (f2$zero 3) (f2rep 3f0))
        #(3f0 3f0 3f0 3f0 3f0 3f0) )

    (vpr (f2$- (f2$zero 3) (f2 3f0 2f0))
        #(-3f0 -2f0 -3f0 -2f0 -3f0 -2f0))))

For more examples go to examples.

You can also see some usagee in the tests.

See docs for automatically generated symbol documentation.

Versions, Issues and feature requests

The most recent stable version is v2.2.0.

This code is still immature, and the interface might change in the future.

To report issues, or suggest features use: Github.


2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 veq

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

Author

<anders hoff / @inconvergent / inconvergent@gmail.com>

License

MIT

Version

2.2.0

Dependencies
  • alexandria (system).
  • sb-cltl2 (system).
  • prove (system).
  • str (system).
Source

veq.asd.

Child Components

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 veq/veq.asd

Source

veq.asd.

Parent Component

veq (system).

ASDF Systems

veq.


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.2 veq/packages.lisp

Source

veq.asd.

Parent Component

veq (system).

Packages

veq.


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.3 veq/config.lisp

Dependency

packages.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

*eps* (special variable).

Internals

3.1.4 veq/utils.lisp

Dependency

config.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.5 veq/array-utils.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.6 veq/docs.lisp

Dependency

utils.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.7 veq/veq-ops.lisp

Dependencies
Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.8 veq/vset.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.9 veq/array-rows.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.10 veq/nsum.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.11 veq/ops-1.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.12 veq/ops-2.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.13 veq/ops-3.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.14 veq/ops-4.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.15 veq/fxlspace.lisp

Dependency

veq-ops.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Internals

3.1.16 veq/macros.lisp

Dependencies
Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.17 veq/array-take.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

make-take-fx (macro).


3.1.18 veq/easing.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

easing-op (macro).


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.19 veq/select-dim.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.20 veq/mat.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.21 veq/mat-inv.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.22 veq/mat-cam.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.23 veq/lspace.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.24 veq/array-print.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface

3.1.25 veq/array-mima.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.26 veq/checks.lisp

Dependency

array-mima.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.27 veq/array-broadcast.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

3.1.28 veq/array-reduce.lisp

Dependency

macros.lisp (file).

Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

-sum-agg (macro).


Previous: , Up: Lisp   [Contents][Index]

3.1.29 veq/shapes.lisp

Dependencies
Source

veq.asd.

Parent Component

veq (system).

Public Interface
Internals

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

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.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


5.1.1 Constants

Constant: dpi
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: fpi5
Package

veq.

Source

utils.lisp.

Constant: fpii
Package

veq.

Source

utils.lisp.


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.2 Special variables

Special Variable: *eps*
Package

veq.

Source

config.lisp.


5.1.3 Macros

Macro: context? ()

list all macrolets in veq context. that is ops available inside vprog, fvprogn, vdef, fvdef defined contexts/functions.

Package

veq.

Source

docs.lisp.

Macro: d$* (&rest rest)

fx: %D$*
macro wrapper: D$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$*! (&rest rest)

fx: %D$*!
macro wrapper: D$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$+ (&rest rest)

fx: %D$+
macro wrapper: D$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$+! (&rest rest)

fx: %D$+!
macro wrapper: D$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$- (&rest rest)

fx: %D$-
macro wrapper: D$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$-! (&rest rest)

fx: %D$-!
macro wrapper: D$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$/ (&rest rest)

fx: %D$/
macro wrapper: D$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$/! (&rest rest)

fx: %D$/!
macro wrapper: D$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$_ (&body body)

create array from body. use either: ($_ (loop repeat 2 collect ‘(1d0 2d0))) or: ($_ ’((1d0 2d0) (1d0 2d0)))

Package

veq.

Source

array-utils.lisp.

Macro: d$abs (&rest rest)

fx: %D$ABS
macro wrapper: D$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$abs! (&rest rest)

fx: %D$ABS!
macro wrapper: D$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$cos-sin (&rest rest)

fx: %D$COS-SIN
macro wrapper: D$COS-SIN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$from (&rest rest)

fx: %D$FROM
macro wrapper: D$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$from! (&rest rest)

fx: %D$FROM!
macro wrapper: D$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$i- (&rest rest)

fx: %D$I-
macro wrapper: D$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$i-! (&rest rest)

fx: %D$I-!
macro wrapper: D$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$i/ (&rest rest)

fx: %D$I/
macro wrapper: D$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$i/! (&rest rest)

fx: %D$I/!
macro wrapper: D$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$iscale (&rest rest)

fx: %D$ISCALE
macro wrapper: D$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$iscale! (&rest rest)

fx: %D$ISCALE!
macro wrapper: D$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$len (&rest rest)

fx: %D$LEN
macro wrapper: D$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$len2 (&rest rest)

fx: %D$LEN2
macro wrapper: D$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$line (&rest rest)

fx: %D$LINE
macro wrapper: D$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d$lspace (&rest rest)

fx: %D$LSPACE
macro wrapper: D$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

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

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

Package

veq.

Source

array-utils.lisp.

Macro: d$neg (&rest rest)

fx: %D$NEG
macro wrapper: D$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$neg! (&rest rest)

fx: %D$NEG!
macro wrapper: D$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$norm (&rest rest)

fx: %D$NORM
macro wrapper: D$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$norm! (&rest rest)

fx: %D$NORM!
macro wrapper: D$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$point (&rest rest)

fx: %D$POINT
macro wrapper: D$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d$scale (&rest rest)

fx: %D$SCALE
macro wrapper: D$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d$scale! (&rest rest)

fx: %D$SCALE!
macro wrapper: D$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$* (&rest rest)

fx: %D2$*
macro wrapper: D2$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$*! (&rest rest)

fx: %D2$*!
macro wrapper: D2$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$+ (&rest rest)

fx: %D2$+
macro wrapper: D2$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$+! (&rest rest)

fx: %D2$+!
macro wrapper: D2$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$- (&rest rest)

fx: %D2$-
macro wrapper: D2$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$-! (&rest rest)

fx: %D2$-!
macro wrapper: D2$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$/ (&rest rest)

fx: %D2$/
macro wrapper: D2$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$/! (&rest rest)

fx: %D2$/!
macro wrapper: D2$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$abs (&rest rest)

fx: %D2$ABS
macro wrapper: D2$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$abs! (&rest rest)

fx: %D2$ABS!
macro wrapper: D2$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$from (&rest rest)

fx: %D2$FROM
macro wrapper: D2$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$from! (&rest rest)

fx: %D2$FROM!
macro wrapper: D2$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$i- (&rest rest)

fx: %D2$I-
macro wrapper: D2$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$i-! (&rest rest)

fx: %D2$I-!
macro wrapper: D2$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$i/ (&rest rest)

fx: %D2$I/
macro wrapper: D2$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$i/! (&rest rest)

fx: %D2$I/!
macro wrapper: D2$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$iscale (&rest rest)

fx: %D2$ISCALE
macro wrapper: D2$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$iscale! (&rest rest)

fx: %D2$ISCALE!
macro wrapper: D2$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$len (&rest rest)

fx: %D2$LEN
macro wrapper: D2$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$len2 (&rest rest)

fx: %D2$LEN2
macro wrapper: D2$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$line (&rest rest)

fx: %D2$LINE
macro wrapper: D2$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d2$lspace (&rest rest)

fx: %D2$LSPACE
macro wrapper: D2$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

Macro: d2$neg (&rest rest)

fx: %D2$NEG
macro wrapper: D2$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$neg! (&rest rest)

fx: %D2$NEG!
macro wrapper: D2$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$norm (&rest rest)

fx: %D2$NORM
macro wrapper: D2$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$norm! (&rest rest)

fx: %D2$NORM!
macro wrapper: D2$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$point (&rest rest)

fx: %D2$POINT
macro wrapper: D2$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d2$rot (&rest rest)

fx: %D2$ROT
macro wrapper: D2$ROT

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$rot! (&rest rest)

fx: %D2$ROT!
macro wrapper: D2$ROT!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$rots (&rest rest)

fx: %D2$ROTS
macro wrapper: D2$ROTS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$rots! (&rest rest)

fx: %D2$ROTS!
macro wrapper: D2$ROTS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$scale (&rest rest)

fx: %D2$SCALE
macro wrapper: D2$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2$scale! (&rest rest)

fx: %D2$SCALE!
macro wrapper: D2$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d2mm (a*349 b*351)

multiply mat * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mmt (a*407 b*409)

multiply mat * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mrot (&rest rest)

fx: %D2MROT
macro wrapper: D2MROT

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: d2mrot* (&rest rest)

fx: %D2MROT*
macro wrapper: D2MROT*

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: d2mscale (&rest rest)

fx: %D2MSCALE
macro wrapper: D2MSCALE

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*436 b*438)

multiply (transpose mat) * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d2mtmt (a*378 b*380)

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

Package

veq.

Source

mat.lisp.

Macro: d2mtrans (&rest rest)

fx: %D2MTRANS
macro wrapper: D2MTRANS

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$* (&rest rest)

fx: %D3$*
macro wrapper: D3$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$*! (&rest rest)

fx: %D3$*!
macro wrapper: D3$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$+ (&rest rest)

fx: %D3$+
macro wrapper: D3$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$+! (&rest rest)

fx: %D3$+!
macro wrapper: D3$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$- (&rest rest)

fx: %D3$-
macro wrapper: D3$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$-! (&rest rest)

fx: %D3$-!
macro wrapper: D3$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$/ (&rest rest)

fx: %D3$/
macro wrapper: D3$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$/! (&rest rest)

fx: %D3$/!
macro wrapper: D3$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$abs (&rest rest)

fx: %D3$ABS
macro wrapper: D3$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$abs! (&rest rest)

fx: %D3$ABS!
macro wrapper: D3$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$from (&rest rest)

fx: %D3$FROM
macro wrapper: D3$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$from! (&rest rest)

fx: %D3$FROM!
macro wrapper: D3$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$i- (&rest rest)

fx: %D3$I-
macro wrapper: D3$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$i-! (&rest rest)

fx: %D3$I-!
macro wrapper: D3$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$i/ (&rest rest)

fx: %D3$I/
macro wrapper: D3$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$i/! (&rest rest)

fx: %D3$I/!
macro wrapper: D3$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$iscale (&rest rest)

fx: %D3$ISCALE
macro wrapper: D3$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$iscale! (&rest rest)

fx: %D3$ISCALE!
macro wrapper: D3$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$len (&rest rest)

fx: %D3$LEN
macro wrapper: D3$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$len2 (&rest rest)

fx: %D3$LEN2
macro wrapper: D3$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$line (&rest rest)

fx: %D3$LINE
macro wrapper: D3$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d3$lspace (&rest rest)

fx: %D3$LSPACE
macro wrapper: D3$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

Macro: d3$neg (&rest rest)

fx: %D3$NEG
macro wrapper: D3$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$neg! (&rest rest)

fx: %D3$NEG!
macro wrapper: D3$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$norm (&rest rest)

fx: %D3$NORM
macro wrapper: D3$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$norm! (&rest rest)

fx: %D3$NORM!
macro wrapper: D3$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$point (&rest rest)

fx: %D3$POINT
macro wrapper: D3$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d3$scale (&rest rest)

fx: %D3$SCALE
macro wrapper: D3$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3$scale! (&rest rest)

fx: %D3$SCALE!
macro wrapper: D3$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d3mm (a*465 b*467)

multiply mat * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mmt (a*523 b*525)

multiply mat * (transpose mat) of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mrot (&rest rest)

fx: %D3MROT
macro wrapper: D3MROT

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: d3mrot* (&rest rest)

fx: %D3MROT*
macro wrapper: D3MROT*

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: d3mscale (&rest rest)

fx: %D3MSCALE
macro wrapper: D3MSCALE

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*552 b*554)

multiply (transpose mat) * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d3mtmt (a*494 b*496)

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

Package

veq.

Source

mat.lisp.

Macro: d3mtrans (&rest rest)

fx: %D3MTRANS
macro wrapper: D3MTRANS

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$* (&rest rest)

fx: %D4$*
macro wrapper: D4$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$*! (&rest rest)

fx: %D4$*!
macro wrapper: D4$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$+ (&rest rest)

fx: %D4$+
macro wrapper: D4$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$+! (&rest rest)

fx: %D4$+!
macro wrapper: D4$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$- (&rest rest)

fx: %D4$-
macro wrapper: D4$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$-! (&rest rest)

fx: %D4$-!
macro wrapper: D4$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$/ (&rest rest)

fx: %D4$/
macro wrapper: D4$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$/! (&rest rest)

fx: %D4$/!
macro wrapper: D4$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$abs (&rest rest)

fx: %D4$ABS
macro wrapper: D4$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$abs! (&rest rest)

fx: %D4$ABS!
macro wrapper: D4$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$from (&rest rest)

fx: %D4$FROM
macro wrapper: D4$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$from! (&rest rest)

fx: %D4$FROM!
macro wrapper: D4$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$i- (&rest rest)

fx: %D4$I-
macro wrapper: D4$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$i-! (&rest rest)

fx: %D4$I-!
macro wrapper: D4$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$i/ (&rest rest)

fx: %D4$I/
macro wrapper: D4$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$i/! (&rest rest)

fx: %D4$I/!
macro wrapper: D4$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$iscale (&rest rest)

fx: %D4$ISCALE
macro wrapper: D4$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$iscale! (&rest rest)

fx: %D4$ISCALE!
macro wrapper: D4$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$len (&rest rest)

fx: %D4$LEN
macro wrapper: D4$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$len2 (&rest rest)

fx: %D4$LEN2
macro wrapper: D4$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$line (&rest rest)

fx: %D4$LINE
macro wrapper: D4$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d4$lspace (&rest rest)

fx: %D4$LSPACE
macro wrapper: D4$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

Macro: d4$neg (&rest rest)

fx: %D4$NEG
macro wrapper: D4$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$neg! (&rest rest)

fx: %D4$NEG!
macro wrapper: D4$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$norm (&rest rest)

fx: %D4$NORM
macro wrapper: D4$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$norm! (&rest rest)

fx: %D4$NORM!
macro wrapper: D4$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$point (&rest rest)

fx: %D4$POINT
macro wrapper: D4$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: d4$scale (&rest rest)

fx: %D4$SCALE
macro wrapper: D4$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4$scale! (&rest rest)

fx: %D4$SCALE!
macro wrapper: D4$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: d4mm (a*581 b*583)

multiply mat * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d4mmt (a*639 b*641)

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*668 b*670)

multiply (transpose mat) * mat of type: DVEC

Package

veq.

Source

mat.lisp.

Macro: d4mtmt (a*610 b*612)

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 from body: (d_ ’(1d0 2d0 3d0))

Package

veq.

Source

array-utils.lisp.

Macro: def* (mname &body body)

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

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

Package

veq.

Source

macros.lisp.

Macro: df (&body body)
Package

veq.

Source

utils.lisp.

Macro: df* (&body body)
Package

veq.

Source

utils.lisp.

Macro: dsb (&rest args)
Package

veq.

Source

utils.lisp.

Macro: dw (&rest rest5040)

macro. reorder arguments (X Y Z W) as (W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dww (&rest rest1200)

macro. reorder arguments (X Y Z W) as (W W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwww (&rest rest240)

macro. reorder arguments (X Y Z W) as (W W W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwww (&rest rest0)

macro. reorder arguments (X Y Z W) as (W W W W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwwx (&rest rest45)

macro. reorder arguments (X Y Z W) as (W W W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwwwy (&rest rest30)

macro. reorder arguments (X Y Z W) as (W W W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwwz (&rest rest15)

macro. reorder arguments (X Y Z W) as (W W W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwx (&rest rest285)

macro. reorder arguments (X Y Z W) as (W W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwwxw (&rest rest180)

macro. reorder arguments (X Y Z W) as (W W X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwwxx (&rest rest225)

macro. reorder arguments (X Y Z W) as (W W X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwwxy (&rest rest210)

macro. reorder arguments (X Y Z W) as (W W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwwxz (&rest rest195)

macro. reorder arguments (X Y Z W) as (W W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwwy (&rest rest270)

macro. reorder arguments (X Y Z W) as (W W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwyw (&rest rest120)

macro. reorder arguments (X Y Z W) as (W W Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwyx (&rest rest165)

macro. reorder arguments (X Y Z W) as (W W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwwyy (&rest rest150)

macro. reorder arguments (X Y Z W) as (W W Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwyz (&rest rest135)

macro. reorder arguments (X Y Z W) as (W W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwz (&rest rest255)

macro. reorder arguments (X Y Z W) as (W W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwzw (&rest rest60)

macro. reorder arguments (X Y Z W) as (W W Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwzx (&rest rest105)

macro. reorder arguments (X Y Z W) as (W W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwwzy (&rest rest90)

macro. reorder arguments (X Y Z W) as (W W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwwzz (&rest rest75)

macro. reorder arguments (X Y Z W) as (W W Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwx (&rest rest1245)

macro. reorder arguments (X Y Z W) as (W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxw (&rest rest1140)

macro. reorder arguments (X Y Z W) as (W X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxww (&rest rest900)

macro. reorder arguments (X Y Z W) as (W X W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxwx (&rest rest945)

macro. reorder arguments (X Y Z W) as (W X W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxwy (&rest rest930)

macro. reorder arguments (X Y Z W) as (W X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwxwz (&rest rest915)

macro. reorder arguments (X Y Z W) as (W X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxx (&rest rest1185)

macro. reorder arguments (X Y Z W) as (W X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxxw (&rest rest1080)

macro. reorder arguments (X Y Z W) as (W X X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxxx (&rest rest1125)

macro. reorder arguments (X Y Z W) as (W X X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxxy (&rest rest1110)

macro. reorder arguments (X Y Z W) as (W X X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwxxz (&rest rest1095)

macro. reorder arguments (X Y Z W) as (W X X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxy (&rest rest1170)

macro. reorder arguments (X Y Z W) as (W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwxyw (&rest rest1020)

macro. reorder arguments (X Y Z W) as (W X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwxyx (&rest rest1065)

macro. reorder arguments (X Y Z W) as (W X Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwxyy (&rest rest1050)

macro. reorder arguments (X Y Z W) as (W X Y Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwxyz (&rest rest1035)

macro. reorder arguments (X Y Z W) as (W X Y Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dwxz (&rest rest1155)

macro. reorder arguments (X Y Z W) as (W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxzw (&rest rest960)

macro. reorder arguments (X Y Z W) as (W X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxzx (&rest rest1005)

macro. reorder arguments (X Y Z W) as (W X Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwxzy (&rest rest990)

macro. reorder arguments (X Y Z W) as (W X Z Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dwxzz (&rest rest975)

macro. reorder arguments (X Y Z W) as (W X Z Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwy (&rest rest1230)

macro. reorder arguments (X Y Z W) as (W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyw (&rest rest840)

macro. reorder arguments (X Y Z W) as (W Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyww (&rest rest600)

macro. reorder arguments (X Y Z W) as (W Y W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwywx (&rest rest645)

macro. reorder arguments (X Y Z W) as (W Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwywy (&rest rest630)

macro. reorder arguments (X Y Z W) as (W Y W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwywz (&rest rest615)

macro. reorder arguments (X Y Z W) as (W Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyx (&rest rest885)

macro. reorder arguments (X Y Z W) as (W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwyxw (&rest rest780)

macro. reorder arguments (X Y Z W) as (W Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwyxx (&rest rest825)

macro. reorder arguments (X Y Z W) as (W Y X X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwyxy (&rest rest810)

macro. reorder arguments (X Y Z W) as (W Y X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwyxz (&rest rest795)

macro. reorder arguments (X Y Z W) as (W Y X Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dwyy (&rest rest870)

macro. reorder arguments (X Y Z W) as (W Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyyw (&rest rest720)

macro. reorder arguments (X Y Z W) as (W Y Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyyx (&rest rest765)

macro. reorder arguments (X Y Z W) as (W Y Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dwyyy (&rest rest750)

macro. reorder arguments (X Y Z W) as (W Y Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyyz (&rest rest735)

macro. reorder arguments (X Y Z W) as (W Y Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyz (&rest rest855)

macro. reorder arguments (X Y Z W) as (W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyzw (&rest rest660)

macro. reorder arguments (X Y Z W) as (W Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyzx (&rest rest705)

macro. reorder arguments (X Y Z W) as (W Y Z X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dwyzy (&rest rest690)

macro. reorder arguments (X Y Z W) as (W Y Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwyzz (&rest rest675)

macro. reorder arguments (X Y Z W) as (W Y Z Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwz (&rest rest1215)

macro. reorder arguments (X Y Z W) as (W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzw (&rest rest540)

macro. reorder arguments (X Y Z W) as (W Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzww (&rest rest300)

macro. reorder arguments (X Y Z W) as (W Z W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzwx (&rest rest345)

macro. reorder arguments (X Y Z W) as (W Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwzwy (&rest rest330)

macro. reorder arguments (X Y Z W) as (W Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzwz (&rest rest315)

macro. reorder arguments (X Y Z W) as (W Z W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzx (&rest rest585)

macro. reorder arguments (X Y Z W) as (W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwzxw (&rest rest480)

macro. reorder arguments (X Y Z W) as (W Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwzxx (&rest rest525)

macro. reorder arguments (X Y Z W) as (W Z X X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwzxy (&rest rest510)

macro. reorder arguments (X Y Z W) as (W Z X Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dwzxz (&rest rest495)

macro. reorder arguments (X Y Z W) as (W Z X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwzy (&rest rest570)

macro. reorder arguments (X Y Z W) as (W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzyw (&rest rest420)

macro. reorder arguments (X Y Z W) as (W Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzyx (&rest rest465)

macro. reorder arguments (X Y Z W) as (W Z Y X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dwzyy (&rest rest450)

macro. reorder arguments (X Y Z W) as (W Z Y Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzyz (&rest rest435)

macro. reorder arguments (X Y Z W) as (W Z Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzz (&rest rest555)

macro. reorder arguments (X Y Z W) as (W Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzzw (&rest rest360)

macro. reorder arguments (X Y Z W) as (W Z Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzzx (&rest rest405)

macro. reorder arguments (X Y Z W) as (W Z Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dwzzy (&rest rest390)

macro. reorder arguments (X Y Z W) as (W Z Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dwzzz (&rest rest375)

macro. reorder arguments (X Y Z W) as (W Z Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dx (&rest rest5085)

macro. reorder arguments (X Y Z W) as (X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxw (&rest rest4980)

macro. reorder arguments (X Y Z W) as (X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxww (&rest rest4020)

macro. reorder arguments (X Y Z W) as (X W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwww (&rest rest3780)

macro. reorder arguments (X Y Z W) as (X W W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwwx (&rest rest3825)

macro. reorder arguments (X Y Z W) as (X W W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwwy (&rest rest3810)

macro. reorder arguments (X Y Z W) as (X W W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxwwz (&rest rest3795)

macro. reorder arguments (X Y Z W) as (X W W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwx (&rest rest4065)

macro. reorder arguments (X Y Z W) as (X W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwxw (&rest rest3960)

macro. reorder arguments (X Y Z W) as (X W X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwxx (&rest rest4005)

macro. reorder arguments (X Y Z W) as (X W X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwxy (&rest rest3990)

macro. reorder arguments (X Y Z W) as (X W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxwxz (&rest rest3975)

macro. reorder arguments (X Y Z W) as (X W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwy (&rest rest4050)

macro. reorder arguments (X Y Z W) as (X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxwyw (&rest rest3900)

macro. reorder arguments (X Y Z W) as (X W Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxwyx (&rest rest3945)

macro. reorder arguments (X Y Z W) as (X W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxwyy (&rest rest3930)

macro. reorder arguments (X Y Z W) as (X W Y Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxwyz (&rest rest3915)

macro. reorder arguments (X Y Z W) as (X W Y Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dxwz (&rest rest4035)

macro. reorder arguments (X Y Z W) as (X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwzw (&rest rest3840)

macro. reorder arguments (X Y Z W) as (X W Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwzx (&rest rest3885)

macro. reorder arguments (X Y Z W) as (X W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxwzy (&rest rest3870)

macro. reorder arguments (X Y Z W) as (X W Z Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dxwzz (&rest rest3855)

macro. reorder arguments (X Y Z W) as (X W Z Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxx (&rest rest5025)

macro. reorder arguments (X Y Z W) as (X X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxw (&rest rest4920)

macro. reorder arguments (X Y Z W) as (X X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxww (&rest rest4680)

macro. reorder arguments (X Y Z W) as (X X W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxwx (&rest rest4725)

macro. reorder arguments (X Y Z W) as (X X W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxwy (&rest rest4710)

macro. reorder arguments (X Y Z W) as (X X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxxwz (&rest rest4695)

macro. reorder arguments (X Y Z W) as (X X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxx (&rest rest4965)

macro. reorder arguments (X Y Z W) as (X X X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxxw (&rest rest4860)

macro. reorder arguments (X Y Z W) as (X X X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxxx (&rest rest4905)

macro. reorder arguments (X Y Z W) as (X X X X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxxy (&rest rest4890)

macro. reorder arguments (X Y Z W) as (X X X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxxxz (&rest rest4875)

macro. reorder arguments (X Y Z W) as (X X X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxy (&rest rest4950)

macro. reorder arguments (X Y Z W) as (X X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxxyw (&rest rest4800)

macro. reorder arguments (X Y Z W) as (X X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxxyx (&rest rest4845)

macro. reorder arguments (X Y Z W) as (X X Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxxyy (&rest rest4830)

macro. reorder arguments (X Y Z W) as (X X Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxxyz (&rest rest4815)

macro. reorder arguments (X Y Z W) as (X X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxxz (&rest rest4935)

macro. reorder arguments (X Y Z W) as (X X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxzw (&rest rest4740)

macro. reorder arguments (X Y Z W) as (X X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxzx (&rest rest4785)

macro. reorder arguments (X Y Z W) as (X X Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxxzy (&rest rest4770)

macro. reorder arguments (X Y Z W) as (X X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxxzz (&rest rest4755)

macro. reorder arguments (X Y Z W) as (X X Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxy (&rest rest5010)

macro. reorder arguments (X Y Z W) as (X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyw (&rest rest4620)

macro. reorder arguments (X Y Z W) as (X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyww (&rest rest4380)

macro. reorder arguments (X Y Z W) as (X Y W W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxywx (&rest rest4425)

macro. reorder arguments (X Y Z W) as (X Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxywy (&rest rest4410)

macro. reorder arguments (X Y Z W) as (X Y W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxywz (&rest rest4395)

macro. reorder arguments (X Y Z W) as (X Y W Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dxyx (&rest rest4665)

macro. reorder arguments (X Y Z W) as (X Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyxw (&rest rest4560)

macro. reorder arguments (X Y Z W) as (X Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyxx (&rest rest4605)

macro. reorder arguments (X Y Z W) as (X Y X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyxy (&rest rest4590)

macro. reorder arguments (X Y Z W) as (X Y X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyxz (&rest rest4575)

macro. reorder arguments (X Y Z W) as (X Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxyy (&rest rest4650)

macro. reorder arguments (X Y Z W) as (X Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyyw (&rest rest4500)

macro. reorder arguments (X Y Z W) as (X Y Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyyx (&rest rest4545)

macro. reorder arguments (X Y Z W) as (X Y Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyyy (&rest rest4530)

macro. reorder arguments (X Y Z W) as (X Y Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dxyyz (&rest rest4515)

macro. reorder arguments (X Y Z W) as (X Y Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxyz (&rest rest4635)

macro. reorder arguments (X Y Z W) as (X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxyzw (&rest rest4440)

macro. reorder arguments (X Y Z W) as (X Y Z W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dxyzx (&rest rest4485)

macro. reorder arguments (X Y Z W) as (X Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxyzy (&rest rest4470)

macro. reorder arguments (X Y Z W) as (X Y Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxyzz (&rest rest4455)

macro. reorder arguments (X Y Z W) as (X Y Z Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxz (&rest rest4995)

macro. reorder arguments (X Y Z W) as (X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzw (&rest rest4320)

macro. reorder arguments (X Y Z W) as (X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzww (&rest rest4080)

macro. reorder arguments (X Y Z W) as (X Z W W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzwx (&rest rest4125)

macro. reorder arguments (X Y Z W) as (X Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzwy (&rest rest4110)

macro. reorder arguments (X Y Z W) as (X Z W Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dxzwz (&rest rest4095)

macro. reorder arguments (X Y Z W) as (X Z W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzx (&rest rest4365)

macro. reorder arguments (X Y Z W) as (X Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzxw (&rest rest4260)

macro. reorder arguments (X Y Z W) as (X Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzxx (&rest rest4305)

macro. reorder arguments (X Y Z W) as (X Z X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzxy (&rest rest4290)

macro. reorder arguments (X Y Z W) as (X Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxzxz (&rest rest4275)

macro. reorder arguments (X Y Z W) as (X Z X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzy (&rest rest4350)

macro. reorder arguments (X Y Z W) as (X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxzyw (&rest rest4200)

macro. reorder arguments (X Y Z W) as (X Z Y W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dxzyx (&rest rest4245)

macro. reorder arguments (X Y Z W) as (X Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxzyy (&rest rest4230)

macro. reorder arguments (X Y Z W) as (X Z Y Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxzyz (&rest rest4215)

macro. reorder arguments (X Y Z W) as (X Z Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxzz (&rest rest4335)

macro. reorder arguments (X Y Z W) as (X Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzzw (&rest rest4140)

macro. reorder arguments (X Y Z W) as (X Z Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzzx (&rest rest4185)

macro. reorder arguments (X Y Z W) as (X Z Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dxzzy (&rest rest4170)

macro. reorder arguments (X Y Z W) as (X Z Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dxzzz (&rest rest4155)

macro. reorder arguments (X Y Z W) as (X Z Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dy (&rest rest5070)

macro. reorder arguments (X Y Z W) as (Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyw (&rest rest3720)

macro. reorder arguments (X Y Z W) as (Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyww (&rest rest2760)

macro. reorder arguments (X Y Z W) as (Y W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dywww (&rest rest2520)

macro. reorder arguments (X Y Z W) as (Y W W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dywwx (&rest rest2565)

macro. reorder arguments (X Y Z W) as (Y W W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dywwy (&rest rest2550)

macro. reorder arguments (X Y Z W) as (Y W W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dywwz (&rest rest2535)

macro. reorder arguments (X Y Z W) as (Y W W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dywx (&rest rest2805)

macro. reorder arguments (X Y Z W) as (Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dywxw (&rest rest2700)

macro. reorder arguments (X Y Z W) as (Y W X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dywxx (&rest rest2745)

macro. reorder arguments (X Y Z W) as (Y W X X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dywxy (&rest rest2730)

macro. reorder arguments (X Y Z W) as (Y W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dywxz (&rest rest2715)

macro. reorder arguments (X Y Z W) as (Y W X Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dywy (&rest rest2790)

macro. reorder arguments (X Y Z W) as (Y W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dywyw (&rest rest2640)

macro. reorder arguments (X Y Z W) as (Y W Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dywyx (&rest rest2685)

macro. reorder arguments (X Y Z W) as (Y W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dywyy (&rest rest2670)

macro. reorder arguments (X Y Z W) as (Y W Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dywyz (&rest rest2655)

macro. reorder arguments (X Y Z W) as (Y W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dywz (&rest rest2775)

macro. reorder arguments (X Y Z W) as (Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dywzw (&rest rest2580)

macro. reorder arguments (X Y Z W) as (Y W Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dywzx (&rest rest2625)

macro. reorder arguments (X Y Z W) as (Y W Z X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dywzy (&rest rest2610)

macro. reorder arguments (X Y Z W) as (Y W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dywzz (&rest rest2595)

macro. reorder arguments (X Y Z W) as (Y W Z Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyx (&rest rest3765)

macro. reorder arguments (X Y Z W) as (Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxw (&rest rest3660)

macro. reorder arguments (X Y Z W) as (Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxww (&rest rest3420)

macro. reorder arguments (X Y Z W) as (Y X W W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxwx (&rest rest3465)

macro. reorder arguments (X Y Z W) as (Y X W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxwy (&rest rest3450)

macro. reorder arguments (X Y Z W) as (Y X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxwz (&rest rest3435)

macro. reorder arguments (X Y Z W) as (Y X W Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dyxx (&rest rest3705)

macro. reorder arguments (X Y Z W) as (Y X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxxw (&rest rest3600)

macro. reorder arguments (X Y Z W) as (Y X X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxxx (&rest rest3645)

macro. reorder arguments (X Y Z W) as (Y X X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxxy (&rest rest3630)

macro. reorder arguments (X Y Z W) as (Y X X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxxz (&rest rest3615)

macro. reorder arguments (X Y Z W) as (Y X X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyxy (&rest rest3690)

macro. reorder arguments (X Y Z W) as (Y X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxyw (&rest rest3540)

macro. reorder arguments (X Y Z W) as (Y X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxyx (&rest rest3585)

macro. reorder arguments (X Y Z W) as (Y X Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxyy (&rest rest3570)

macro. reorder arguments (X Y Z W) as (Y X Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyxyz (&rest rest3555)

macro. reorder arguments (X Y Z W) as (Y X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyxz (&rest rest3675)

macro. reorder arguments (X Y Z W) as (Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyxzw (&rest rest3480)

macro. reorder arguments (X Y Z W) as (Y X Z W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dyxzx (&rest rest3525)

macro. reorder arguments (X Y Z W) as (Y X Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyxzy (&rest rest3510)

macro. reorder arguments (X Y Z W) as (Y X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyxzz (&rest rest3495)

macro. reorder arguments (X Y Z W) as (Y X Z Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyy (&rest rest3750)

macro. reorder arguments (X Y Z W) as (Y Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyw (&rest rest3360)

macro. reorder arguments (X Y Z W) as (Y Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyww (&rest rest3120)

macro. reorder arguments (X Y Z W) as (Y Y W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyywx (&rest rest3165)

macro. reorder arguments (X Y Z W) as (Y Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyywy (&rest rest3150)

macro. reorder arguments (X Y Z W) as (Y Y W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyywz (&rest rest3135)

macro. reorder arguments (X Y Z W) as (Y Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyx (&rest rest3405)

macro. reorder arguments (X Y Z W) as (Y Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyyxw (&rest rest3300)

macro. reorder arguments (X Y Z W) as (Y Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyyxx (&rest rest3345)

macro. reorder arguments (X Y Z W) as (Y Y X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyyxy (&rest rest3330)

macro. reorder arguments (X Y Z W) as (Y Y X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyyxz (&rest rest3315)

macro. reorder arguments (X Y Z W) as (Y Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyyy (&rest rest3390)

macro. reorder arguments (X Y Z W) as (Y Y Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyyw (&rest rest3240)

macro. reorder arguments (X Y Z W) as (Y Y Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyyx (&rest rest3285)

macro. reorder arguments (X Y Z W) as (Y Y Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: dyyyy (&rest rest3270)

macro. reorder arguments (X Y Z W) as (Y Y Y Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyyz (&rest rest3255)

macro. reorder arguments (X Y Z W) as (Y Y Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyz (&rest rest3375)

macro. reorder arguments (X Y Z W) as (Y Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyzw (&rest rest3180)

macro. reorder arguments (X Y Z W) as (Y Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyzx (&rest rest3225)

macro. reorder arguments (X Y Z W) as (Y Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyyzy (&rest rest3210)

macro. reorder arguments (X Y Z W) as (Y Y Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyyzz (&rest rest3195)

macro. reorder arguments (X Y Z W) as (Y Y Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyz (&rest rest3735)

macro. reorder arguments (X Y Z W) as (Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzw (&rest rest3060)

macro. reorder arguments (X Y Z W) as (Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzww (&rest rest2820)

macro. reorder arguments (X Y Z W) as (Y Z W W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzwx (&rest rest2865)

macro. reorder arguments (X Y Z W) as (Y Z W X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dyzwy (&rest rest2850)

macro. reorder arguments (X Y Z W) as (Y Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzwz (&rest rest2835)

macro. reorder arguments (X Y Z W) as (Y Z W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzx (&rest rest3105)

macro. reorder arguments (X Y Z W) as (Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyzxw (&rest rest3000)

macro. reorder arguments (X Y Z W) as (Y Z X W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dyzxx (&rest rest3045)

macro. reorder arguments (X Y Z W) as (Y Z X X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyzxy (&rest rest3030)

macro. reorder arguments (X Y Z W) as (Y Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyzxz (&rest rest3015)

macro. reorder arguments (X Y Z W) as (Y Z X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyzy (&rest rest3090)

macro. reorder arguments (X Y Z W) as (Y Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzyw (&rest rest2940)

macro. reorder arguments (X Y Z W) as (Y Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzyx (&rest rest2985)

macro. reorder arguments (X Y Z W) as (Y Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyzyy (&rest rest2970)

macro. reorder arguments (X Y Z W) as (Y Z Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzyz (&rest rest2955)

macro. reorder arguments (X Y Z W) as (Y Z Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzz (&rest rest3075)

macro. reorder arguments (X Y Z W) as (Y Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzzw (&rest rest2880)

macro. reorder arguments (X Y Z W) as (Y Z Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzzx (&rest rest2925)

macro. reorder arguments (X Y Z W) as (Y Z Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dyzzy (&rest rest2910)

macro. reorder arguments (X Y Z W) as (Y Z Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dyzzz (&rest rest2895)

macro. reorder arguments (X Y Z W) as (Y Z Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dz (&rest rest5055)

macro. reorder arguments (X Y Z W) as (Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzw (&rest rest2460)

macro. reorder arguments (X Y Z W) as (Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzww (&rest rest1500)

macro. reorder arguments (X Y Z W) as (Z W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwww (&rest rest1260)

macro. reorder arguments (X Y Z W) as (Z W W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwwx (&rest rest1305)

macro. reorder arguments (X Y Z W) as (Z W W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzwwy (&rest rest1290)

macro. reorder arguments (X Y Z W) as (Z W W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwwz (&rest rest1275)

macro. reorder arguments (X Y Z W) as (Z W W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwx (&rest rest1545)

macro. reorder arguments (X Y Z W) as (Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzwxw (&rest rest1440)

macro. reorder arguments (X Y Z W) as (Z W X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzwxx (&rest rest1485)

macro. reorder arguments (X Y Z W) as (Z W X X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzwxy (&rest rest1470)

macro. reorder arguments (X Y Z W) as (Z W X Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dzwxz (&rest rest1455)

macro. reorder arguments (X Y Z W) as (Z W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzwy (&rest rest1530)

macro. reorder arguments (X Y Z W) as (Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwyw (&rest rest1380)

macro. reorder arguments (X Y Z W) as (Z W Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwyx (&rest rest1425)

macro. reorder arguments (X Y Z W) as (Z W Y X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dzwyy (&rest rest1410)

macro. reorder arguments (X Y Z W) as (Z W Y Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwyz (&rest rest1395)

macro. reorder arguments (X Y Z W) as (Z W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwz (&rest rest1515)

macro. reorder arguments (X Y Z W) as (Z W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwzw (&rest rest1320)

macro. reorder arguments (X Y Z W) as (Z W Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwzx (&rest rest1365)

macro. reorder arguments (X Y Z W) as (Z W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzwzy (&rest rest1350)

macro. reorder arguments (X Y Z W) as (Z W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzwzz (&rest rest1335)

macro. reorder arguments (X Y Z W) as (Z W Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzx (&rest rest2505)

macro. reorder arguments (X Y Z W) as (Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxw (&rest rest2400)

macro. reorder arguments (X Y Z W) as (Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxww (&rest rest2160)

macro. reorder arguments (X Y Z W) as (Z X W W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxwx (&rest rest2205)

macro. reorder arguments (X Y Z W) as (Z X W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxwy (&rest rest2190)

macro. reorder arguments (X Y Z W) as (Z X W Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dzxwz (&rest rest2175)

macro. reorder arguments (X Y Z W) as (Z X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxx (&rest rest2445)

macro. reorder arguments (X Y Z W) as (Z X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxxw (&rest rest2340)

macro. reorder arguments (X Y Z W) as (Z X X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxxx (&rest rest2385)

macro. reorder arguments (X Y Z W) as (Z X X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxxy (&rest rest2370)

macro. reorder arguments (X Y Z W) as (Z X X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzxxz (&rest rest2355)

macro. reorder arguments (X Y Z W) as (Z X X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxy (&rest rest2430)

macro. reorder arguments (X Y Z W) as (Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzxyw (&rest rest2280)

macro. reorder arguments (X Y Z W) as (Z X Y W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dzxyx (&rest rest2325)

macro. reorder arguments (X Y Z W) as (Z X Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzxyy (&rest rest2310)

macro. reorder arguments (X Y Z W) as (Z X Y Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzxyz (&rest rest2295)

macro. reorder arguments (X Y Z W) as (Z X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzxz (&rest rest2415)

macro. reorder arguments (X Y Z W) as (Z X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxzw (&rest rest2220)

macro. reorder arguments (X Y Z W) as (Z X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxzx (&rest rest2265)

macro. reorder arguments (X Y Z W) as (Z X Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzxzy (&rest rest2250)

macro. reorder arguments (X Y Z W) as (Z X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzxzz (&rest rest2235)

macro. reorder arguments (X Y Z W) as (Z X Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzy (&rest rest2490)

macro. reorder arguments (X Y Z W) as (Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyw (&rest rest2100)

macro. reorder arguments (X Y Z W) as (Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyww (&rest rest1860)

macro. reorder arguments (X Y Z W) as (Z Y W W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzywx (&rest rest1905)

macro. reorder arguments (X Y Z W) as (Z Y W X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dzywy (&rest rest1890)

macro. reorder arguments (X Y Z W) as (Z Y W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzywz (&rest rest1875)

macro. reorder arguments (X Y Z W) as (Z Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyx (&rest rest2145)

macro. reorder arguments (X Y Z W) as (Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzyxw (&rest rest2040)

macro. reorder arguments (X Y Z W) as (Z Y X W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: dzyxx (&rest rest2085)

macro. reorder arguments (X Y Z W) as (Z Y X X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzyxy (&rest rest2070)

macro. reorder arguments (X Y Z W) as (Z Y X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzyxz (&rest rest2055)

macro. reorder arguments (X Y Z W) as (Z Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzyy (&rest rest2130)

macro. reorder arguments (X Y Z W) as (Z Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyyw (&rest rest1980)

macro. reorder arguments (X Y Z W) as (Z Y Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyyx (&rest rest2025)

macro. reorder arguments (X Y Z W) as (Z Y Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzyyy (&rest rest2010)

macro. reorder arguments (X Y Z W) as (Z Y Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyyz (&rest rest1995)

macro. reorder arguments (X Y Z W) as (Z Y Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyz (&rest rest2115)

macro. reorder arguments (X Y Z W) as (Z Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyzw (&rest rest1920)

macro. reorder arguments (X Y Z W) as (Z Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyzx (&rest rest1965)

macro. reorder arguments (X Y Z W) as (Z Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzyzy (&rest rest1950)

macro. reorder arguments (X Y Z W) as (Z Y Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzyzz (&rest rest1935)

macro. reorder arguments (X Y Z W) as (Z Y Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzz (&rest rest2475)

macro. reorder arguments (X Y Z W) as (Z Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzw (&rest rest1800)

macro. reorder arguments (X Y Z W) as (Z Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzww (&rest rest1560)

macro. reorder arguments (X Y Z W) as (Z Z W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzwx (&rest rest1605)

macro. reorder arguments (X Y Z W) as (Z Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzzwy (&rest rest1590)

macro. reorder arguments (X Y Z W) as (Z Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzwz (&rest rest1575)

macro. reorder arguments (X Y Z W) as (Z Z W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzx (&rest rest1845)

macro. reorder arguments (X Y Z W) as (Z Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzzxw (&rest rest1740)

macro. reorder arguments (X Y Z W) as (Z Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzzxx (&rest rest1785)

macro. reorder arguments (X Y Z W) as (Z Z X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzzxy (&rest rest1770)

macro. reorder arguments (X Y Z W) as (Z Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzzxz (&rest rest1755)

macro. reorder arguments (X Y Z W) as (Z Z X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzzy (&rest rest1830)

macro. reorder arguments (X Y Z W) as (Z Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzyw (&rest rest1680)

macro. reorder arguments (X Y Z W) as (Z Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzyx (&rest rest1725)

macro. reorder arguments (X Y Z W) as (Z Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: dzzyy (&rest rest1710)

macro. reorder arguments (X Y Z W) as (Z Z Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzyz (&rest rest1695)

macro. reorder arguments (X Y Z W) as (Z Z Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzz (&rest rest1815)

macro. reorder arguments (X Y Z W) as (Z Z Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzzw (&rest rest1620)

macro. reorder arguments (X Y Z W) as (Z Z Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzzx (&rest rest1665)

macro. reorder arguments (X Y Z W) as (Z Z Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: dzzzy (&rest rest1650)

macro. reorder arguments (X Y Z W) as (Z Z Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: dzzzz (&rest rest1635)

macro. reorder arguments (X Y Z W) as (Z Z Z Z), (IGNORE W Y X).

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$* (&rest rest)

fx: %F$*
macro wrapper: F$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$*! (&rest rest)

fx: %F$*!
macro wrapper: F$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$+ (&rest rest)

fx: %F$+
macro wrapper: F$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$+! (&rest rest)

fx: %F$+!
macro wrapper: F$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$- (&rest rest)

fx: %F$-
macro wrapper: F$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$-! (&rest rest)

fx: %F$-!
macro wrapper: F$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$/ (&rest rest)

fx: %F$/
macro wrapper: F$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$/! (&rest rest)

fx: %F$/!
macro wrapper: F$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$_ (&body body)

create array from body. use either: ($_ (loop repeat 2 collect ‘(1d0 2d0))) or: ($_ ’((1d0 2d0) (1d0 2d0)))

Package

veq.

Source

array-utils.lisp.

Macro: f$abs (&rest rest)

fx: %F$ABS
macro wrapper: F$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$abs! (&rest rest)

fx: %F$ABS!
macro wrapper: F$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$cos-sin (&rest rest)

fx: %F$COS-SIN
macro wrapper: F$COS-SIN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$from (&rest rest)

fx: %F$FROM
macro wrapper: F$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$from! (&rest rest)

fx: %F$FROM!
macro wrapper: F$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$i- (&rest rest)

fx: %F$I-
macro wrapper: F$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$i-! (&rest rest)

fx: %F$I-!
macro wrapper: F$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$i/ (&rest rest)

fx: %F$I/
macro wrapper: F$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$i/! (&rest rest)

fx: %F$I/!
macro wrapper: F$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$iscale (&rest rest)

fx: %F$ISCALE
macro wrapper: F$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$iscale! (&rest rest)

fx: %F$ISCALE!
macro wrapper: F$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$len (&rest rest)

fx: %F$LEN
macro wrapper: F$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$len2 (&rest rest)

fx: %F$LEN2
macro wrapper: F$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$line (&rest rest)

fx: %F$LINE
macro wrapper: F$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f$lspace (&rest rest)

fx: %F$LSPACE
macro wrapper: F$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

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

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

Package

veq.

Source

array-utils.lisp.

Macro: f$neg (&rest rest)

fx: %F$NEG
macro wrapper: F$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$neg! (&rest rest)

fx: %F$NEG!
macro wrapper: F$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$norm (&rest rest)

fx: %F$NORM
macro wrapper: F$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$norm! (&rest rest)

fx: %F$NORM!
macro wrapper: F$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$point (&rest rest)

fx: %F$POINT
macro wrapper: F$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f$scale (&rest rest)

fx: %F$SCALE
macro wrapper: F$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f$scale! (&rest rest)

fx: %F$SCALE!
macro wrapper: F$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$* (&rest rest)

fx: %F2$*
macro wrapper: F2$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$*! (&rest rest)

fx: %F2$*!
macro wrapper: F2$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$+ (&rest rest)

fx: %F2$+
macro wrapper: F2$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$+! (&rest rest)

fx: %F2$+!
macro wrapper: F2$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$- (&rest rest)

fx: %F2$-
macro wrapper: F2$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$-! (&rest rest)

fx: %F2$-!
macro wrapper: F2$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$/ (&rest rest)

fx: %F2$/
macro wrapper: F2$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$/! (&rest rest)

fx: %F2$/!
macro wrapper: F2$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$abs (&rest rest)

fx: %F2$ABS
macro wrapper: F2$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$abs! (&rest rest)

fx: %F2$ABS!
macro wrapper: F2$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$center (&rest rest)

fx: %F2$CENTER
macro wrapper: F2$CENTER

defined via veq:fvdef*

Package

veq.

Source

shapes.lisp.

Macro: f2$circ (&rest rest)

fx: %F2$CIRC
macro wrapper: F2$CIRC

defined via veq:fvdef*

Package

veq.

Source

shapes.lisp.

Macro: f2$from (&rest rest)

fx: %F2$FROM
macro wrapper: F2$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$from! (&rest rest)

fx: %F2$FROM!
macro wrapper: F2$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$i- (&rest rest)

fx: %F2$I-
macro wrapper: F2$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$i-! (&rest rest)

fx: %F2$I-!
macro wrapper: F2$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$i/ (&rest rest)

fx: %F2$I/
macro wrapper: F2$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$i/! (&rest rest)

fx: %F2$I/!
macro wrapper: F2$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$iscale (&rest rest)

fx: %F2$ISCALE
macro wrapper: F2$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$iscale! (&rest rest)

fx: %F2$ISCALE!
macro wrapper: F2$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$len (&rest rest)

fx: %F2$LEN
macro wrapper: F2$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$len2 (&rest rest)

fx: %F2$LEN2
macro wrapper: F2$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$line (&rest rest)

fx: %F2$LINE
macro wrapper: F2$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f2$lspace (&rest rest)

fx: %F2$LSPACE
macro wrapper: F2$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

Macro: f2$neg (&rest rest)

fx: %F2$NEG
macro wrapper: F2$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$neg! (&rest rest)

fx: %F2$NEG!
macro wrapper: F2$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$norm (&rest rest)

fx: %F2$NORM
macro wrapper: F2$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$norm! (&rest rest)

fx: %F2$NORM!
macro wrapper: F2$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$point (&rest rest)

fx: %F2$POINT
macro wrapper: F2$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f2$polygon (&rest rest)

fx: %F2$POLYGON
macro wrapper: F2$POLYGON

defined via veq:fvdef*

Package

veq.

Source

shapes.lisp.

Macro: f2$rect (&rest rest)

fx: %F2$RECT
macro wrapper: F2$RECT

defined via veq:fvdef*

Package

veq.

Source

shapes.lisp.

Macro: f2$rot (&rest rest)

fx: %F2$ROT
macro wrapper: F2$ROT

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$rot! (&rest rest)

fx: %F2$ROT!
macro wrapper: F2$ROT!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$rots (&rest rest)

fx: %F2$ROTS
macro wrapper: F2$ROTS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$rots! (&rest rest)

fx: %F2$ROTS!
macro wrapper: F2$ROTS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$scale (&rest rest)

fx: %F2$SCALE
macro wrapper: F2$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$scale! (&rest rest)

fx: %F2$SCALE!
macro wrapper: F2$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f2$square (&rest rest)

fx: %F2$SQUARE
macro wrapper: F2$SQUARE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f2in-bbox (&rest rest)

fx: %F2IN-BBOX
macro wrapper: F2IN-BBOX

defined via veq:fvdef*

Package

veq.

Source

checks.lisp.

Macro: f2in-concave (&rest rest)

fx: %F2IN-CONCAVE
macro wrapper: F2IN-CONCAVE

defined via veq:fvdef*

Package

veq.

Source

checks.lisp.

Macro: f2in-triangle (&rest rest)

fx: %F2IN-TRIANGLE
macro wrapper: F2IN-TRIANGLE

defined via veq:fvdef*

Package

veq.

Source

checks.lisp.

Macro: f2lsegx (&rest rest)

fx: %F2LSEGX
macro wrapper: F2LSEGX

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*59 b*61)

multiply mat * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f2mrot (&rest rest)

fx: %F2MROT
macro wrapper: F2MROT

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: f2mrot* (&rest rest)

fx: %F2MROT*
macro wrapper: F2MROT*

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: f2mscale (&rest rest)

fx: %F2MSCALE
macro wrapper: F2MSCALE

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*88 b*90)

multiply (transpose mat) * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f2mtmt (a*30 b*32)

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

Package

veq.

Source

mat.lisp.

Macro: f2mtrans (&rest rest)

fx: %F2MTRANS
macro wrapper: F2MTRANS

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)

fx: %F2SEGDST
macro wrapper: F2SEGDST

defined via veq:fvdef*

Package

veq.

Source

checks.lisp.

Macro: f2segx (&rest rest)

fx: %F2SEGX
macro wrapper: F2SEGX

defined via veq:fvdef*

Package

veq.

Source

checks.lisp.

Macro: f3$* (&rest rest)

fx: %F3$*
macro wrapper: F3$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$*! (&rest rest)

fx: %F3$*!
macro wrapper: F3$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$+ (&rest rest)

fx: %F3$+
macro wrapper: F3$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$+! (&rest rest)

fx: %F3$+!
macro wrapper: F3$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$- (&rest rest)

fx: %F3$-
macro wrapper: F3$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$-! (&rest rest)

fx: %F3$-!
macro wrapper: F3$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$/ (&rest rest)

fx: %F3$/
macro wrapper: F3$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$/! (&rest rest)

fx: %F3$/!
macro wrapper: F3$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$abs (&rest rest)

fx: %F3$ABS
macro wrapper: F3$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$abs! (&rest rest)

fx: %F3$ABS!
macro wrapper: F3$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$from (&rest rest)

fx: %F3$FROM
macro wrapper: F3$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$from! (&rest rest)

fx: %F3$FROM!
macro wrapper: F3$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$i- (&rest rest)

fx: %F3$I-
macro wrapper: F3$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$i-! (&rest rest)

fx: %F3$I-!
macro wrapper: F3$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$i/ (&rest rest)

fx: %F3$I/
macro wrapper: F3$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$i/! (&rest rest)

fx: %F3$I/!
macro wrapper: F3$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$iscale (&rest rest)

fx: %F3$ISCALE
macro wrapper: F3$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$iscale! (&rest rest)

fx: %F3$ISCALE!
macro wrapper: F3$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$len (&rest rest)

fx: %F3$LEN
macro wrapper: F3$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$len2 (&rest rest)

fx: %F3$LEN2
macro wrapper: F3$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$line (&rest rest)

fx: %F3$LINE
macro wrapper: F3$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f3$lspace (&rest rest)

fx: %F3$LSPACE
macro wrapper: F3$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

Macro: f3$neg (&rest rest)

fx: %F3$NEG
macro wrapper: F3$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$neg! (&rest rest)

fx: %F3$NEG!
macro wrapper: F3$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$norm (&rest rest)

fx: %F3$NORM
macro wrapper: F3$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$norm! (&rest rest)

fx: %F3$NORM!
macro wrapper: F3$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$point (&rest rest)

fx: %F3$POINT
macro wrapper: F3$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f3$scale (&rest rest)

fx: %F3$SCALE
macro wrapper: F3$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3$scale! (&rest rest)

fx: %F3$SCALE!
macro wrapper: F3$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f3mm (a*117 b*119)

multiply mat * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mmt (a*175 b*177)

multiply mat * (transpose mat) of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mrot (&rest rest)

fx: %F3MROT
macro wrapper: F3MROT

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: f3mrot* (&rest rest)

fx: %F3MROT*
macro wrapper: F3MROT*

defined via veq:def*

Package

veq.

Source

mat.lisp.

Macro: f3mscale (&rest rest)

fx: %F3MSCALE
macro wrapper: F3MSCALE

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*204 b*206)

multiply (transpose mat) * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f3mtmt (a*146 b*148)

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

Package

veq.

Source

mat.lisp.

Macro: f3mtrans (&rest rest)

fx: %F3MTRANS
macro wrapper: F3MTRANS

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)

fx: %F3PLANEX
macro wrapper: F3PLANEX

defined via veq:fvdef*

Package

veq.

Source

checks.lisp.

Macro: f4$* (&rest rest)

fx: %F4$*
macro wrapper: F4$*

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$*! (&rest rest)

fx: %F4$*!
macro wrapper: F4$*!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$+ (&rest rest)

fx: %F4$+
macro wrapper: F4$+

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$+! (&rest rest)

fx: %F4$+!
macro wrapper: F4$+!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$- (&rest rest)

fx: %F4$-
macro wrapper: F4$-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$-! (&rest rest)

fx: %F4$-!
macro wrapper: F4$-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$/ (&rest rest)

fx: %F4$/
macro wrapper: F4$/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$/! (&rest rest)

fx: %F4$/!
macro wrapper: F4$/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$abs (&rest rest)

fx: %F4$ABS
macro wrapper: F4$ABS

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$abs! (&rest rest)

fx: %F4$ABS!
macro wrapper: F4$ABS!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$from (&rest rest)

fx: %F4$FROM
macro wrapper: F4$FROM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$from! (&rest rest)

fx: %F4$FROM!
macro wrapper: F4$FROM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$i- (&rest rest)

fx: %F4$I-
macro wrapper: F4$I-

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$i-! (&rest rest)

fx: %F4$I-!
macro wrapper: F4$I-!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$i/ (&rest rest)

fx: %F4$I/
macro wrapper: F4$I/

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$i/! (&rest rest)

fx: %F4$I/!
macro wrapper: F4$I/!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$iscale (&rest rest)

fx: %F4$ISCALE
macro wrapper: F4$ISCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$iscale! (&rest rest)

fx: %F4$ISCALE!
macro wrapper: F4$ISCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$len (&rest rest)

fx: %F4$LEN
macro wrapper: F4$LEN

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$len2 (&rest rest)

fx: %F4$LEN2
macro wrapper: F4$LEN2

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$line (&rest rest)

fx: %F4$LINE
macro wrapper: F4$LINE

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f4$lspace (&rest rest)

fx: %F4$LSPACE
macro wrapper: F4$LSPACE

defined via veq:fvdef*

Package

veq.

Source

lspace.lisp.

Macro: f4$neg (&rest rest)

fx: %F4$NEG
macro wrapper: F4$NEG

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$neg! (&rest rest)

fx: %F4$NEG!
macro wrapper: F4$NEG!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$norm (&rest rest)

fx: %F4$NORM
macro wrapper: F4$NORM

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$norm! (&rest rest)

fx: %F4$NORM!
macro wrapper: F4$NORM!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$point (&rest rest)

fx: %F4$POINT
macro wrapper: F4$POINT

defined via veq:def*

Package

veq.

Source

shapes.lisp.

Macro: f4$scale (&rest rest)

fx: %F4$SCALE
macro wrapper: F4$SCALE

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4$scale! (&rest rest)

fx: %F4$SCALE!
macro wrapper: F4$SCALE!

defined via veq:def*

Package

veq.

Source

array-broadcast.lisp.

Macro: f4mm (a*233 b*235)

multiply mat * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f4mmt (a*291 b*293)

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*320 b*322)

multiply (transpose mat) * mat of type: FVEC

Package

veq.

Source

mat.lisp.

Macro: f4mtmt (a*262 b*264)

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 from body: (f_ ’(1f0 2f0 3f0))

Package

veq.

Source

array-utils.lisp.

Macro: ff (&body body)
Package

veq.

Source

utils.lisp.

Macro: ff* (&body body)
Package

veq.

Source

utils.lisp.

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

fx: %FMAKE-ORTHO-PROJ-MATRIX
macro wrapper: FMAKE-ORTHO-PROJ-MATRIX

defined via veq:fvdef*

Package

veq.

Source

mat-cam.lisp.

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

fx: %FMAKE-PROJ-MATRIX
macro wrapper: FMAKE-PROJ-MATRIX

defined via veq:fvdef*

Package

veq.

Source

mat-cam.lisp.

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

fx: %FMAKE-VIEW-MATRIX
macro wrapper: FMAKE-VIEW-MATRIX

defined via veq:fvdef*

Package

veq.

Source

mat-cam.lisp.

Macro: from-lst (l)

get values from list

Package

veq.

Source

macros.lisp.

Macro: fvdef (fname &body body)

define function with veq context enabled. uses fvprogn.

Package

veq.

Source

macros.lisp.

Macro: fvdef* (mname &body body)

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

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

Package

veq.

Source

macros.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).

works the same way as vprogn. but removes all macrolets that are not directly used 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

macros.lisp.

Macro: fw (&rest rest5040)

macro. reorder arguments (X Y Z W) as (W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fww (&rest rest1200)

macro. reorder arguments (X Y Z W) as (W W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwww (&rest rest240)

macro. reorder arguments (X Y Z W) as (W W W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwww (&rest rest0)

macro. reorder arguments (X Y Z W) as (W W W W), (IGNORE Z Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwwx (&rest rest45)

macro. reorder arguments (X Y Z W) as (W W W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwwwy (&rest rest30)

macro. reorder arguments (X Y Z W) as (W W W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwwz (&rest rest15)

macro. reorder arguments (X Y Z W) as (W W W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwx (&rest rest285)

macro. reorder arguments (X Y Z W) as (W W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwwxw (&rest rest180)

macro. reorder arguments (X Y Z W) as (W W X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwwxx (&rest rest225)

macro. reorder arguments (X Y Z W) as (W W X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwwxy (&rest rest210)

macro. reorder arguments (X Y Z W) as (W W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwwxz (&rest rest195)

macro. reorder arguments (X Y Z W) as (W W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwwy (&rest rest270)

macro. reorder arguments (X Y Z W) as (W W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwyw (&rest rest120)

macro. reorder arguments (X Y Z W) as (W W Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwyx (&rest rest165)

macro. reorder arguments (X Y Z W) as (W W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwwyy (&rest rest150)

macro. reorder arguments (X Y Z W) as (W W Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwyz (&rest rest135)

macro. reorder arguments (X Y Z W) as (W W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwz (&rest rest255)

macro. reorder arguments (X Y Z W) as (W W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwzw (&rest rest60)

macro. reorder arguments (X Y Z W) as (W W Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwzx (&rest rest105)

macro. reorder arguments (X Y Z W) as (W W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwwzy (&rest rest90)

macro. reorder arguments (X Y Z W) as (W W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwwzz (&rest rest75)

macro. reorder arguments (X Y Z W) as (W W Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwx (&rest rest1245)

macro. reorder arguments (X Y Z W) as (W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxw (&rest rest1140)

macro. reorder arguments (X Y Z W) as (W X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxww (&rest rest900)

macro. reorder arguments (X Y Z W) as (W X W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxwx (&rest rest945)

macro. reorder arguments (X Y Z W) as (W X W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxwy (&rest rest930)

macro. reorder arguments (X Y Z W) as (W X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwxwz (&rest rest915)

macro. reorder arguments (X Y Z W) as (W X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxx (&rest rest1185)

macro. reorder arguments (X Y Z W) as (W X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxxw (&rest rest1080)

macro. reorder arguments (X Y Z W) as (W X X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxxx (&rest rest1125)

macro. reorder arguments (X Y Z W) as (W X X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxxy (&rest rest1110)

macro. reorder arguments (X Y Z W) as (W X X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwxxz (&rest rest1095)

macro. reorder arguments (X Y Z W) as (W X X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxy (&rest rest1170)

macro. reorder arguments (X Y Z W) as (W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwxyw (&rest rest1020)

macro. reorder arguments (X Y Z W) as (W X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwxyx (&rest rest1065)

macro. reorder arguments (X Y Z W) as (W X Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwxyy (&rest rest1050)

macro. reorder arguments (X Y Z W) as (W X Y Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwxyz (&rest rest1035)

macro. reorder arguments (X Y Z W) as (W X Y Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fwxz (&rest rest1155)

macro. reorder arguments (X Y Z W) as (W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxzw (&rest rest960)

macro. reorder arguments (X Y Z W) as (W X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxzx (&rest rest1005)

macro. reorder arguments (X Y Z W) as (W X Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwxzy (&rest rest990)

macro. reorder arguments (X Y Z W) as (W X Z Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fwxzz (&rest rest975)

macro. reorder arguments (X Y Z W) as (W X Z Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwy (&rest rest1230)

macro. reorder arguments (X Y Z W) as (W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyw (&rest rest840)

macro. reorder arguments (X Y Z W) as (W Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyww (&rest rest600)

macro. reorder arguments (X Y Z W) as (W Y W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwywx (&rest rest645)

macro. reorder arguments (X Y Z W) as (W Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwywy (&rest rest630)

macro. reorder arguments (X Y Z W) as (W Y W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwywz (&rest rest615)

macro. reorder arguments (X Y Z W) as (W Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyx (&rest rest885)

macro. reorder arguments (X Y Z W) as (W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwyxw (&rest rest780)

macro. reorder arguments (X Y Z W) as (W Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwyxx (&rest rest825)

macro. reorder arguments (X Y Z W) as (W Y X X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwyxy (&rest rest810)

macro. reorder arguments (X Y Z W) as (W Y X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwyxz (&rest rest795)

macro. reorder arguments (X Y Z W) as (W Y X Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fwyy (&rest rest870)

macro. reorder arguments (X Y Z W) as (W Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyyw (&rest rest720)

macro. reorder arguments (X Y Z W) as (W Y Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyyx (&rest rest765)

macro. reorder arguments (X Y Z W) as (W Y Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fwyyy (&rest rest750)

macro. reorder arguments (X Y Z W) as (W Y Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyyz (&rest rest735)

macro. reorder arguments (X Y Z W) as (W Y Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyz (&rest rest855)

macro. reorder arguments (X Y Z W) as (W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyzw (&rest rest660)

macro. reorder arguments (X Y Z W) as (W Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyzx (&rest rest705)

macro. reorder arguments (X Y Z W) as (W Y Z X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fwyzy (&rest rest690)

macro. reorder arguments (X Y Z W) as (W Y Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwyzz (&rest rest675)

macro. reorder arguments (X Y Z W) as (W Y Z Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwz (&rest rest1215)

macro. reorder arguments (X Y Z W) as (W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzw (&rest rest540)

macro. reorder arguments (X Y Z W) as (W Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzww (&rest rest300)

macro. reorder arguments (X Y Z W) as (W Z W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzwx (&rest rest345)

macro. reorder arguments (X Y Z W) as (W Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwzwy (&rest rest330)

macro. reorder arguments (X Y Z W) as (W Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzwz (&rest rest315)

macro. reorder arguments (X Y Z W) as (W Z W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzx (&rest rest585)

macro. reorder arguments (X Y Z W) as (W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwzxw (&rest rest480)

macro. reorder arguments (X Y Z W) as (W Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwzxx (&rest rest525)

macro. reorder arguments (X Y Z W) as (W Z X X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwzxy (&rest rest510)

macro. reorder arguments (X Y Z W) as (W Z X Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fwzxz (&rest rest495)

macro. reorder arguments (X Y Z W) as (W Z X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwzy (&rest rest570)

macro. reorder arguments (X Y Z W) as (W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzyw (&rest rest420)

macro. reorder arguments (X Y Z W) as (W Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzyx (&rest rest465)

macro. reorder arguments (X Y Z W) as (W Z Y X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fwzyy (&rest rest450)

macro. reorder arguments (X Y Z W) as (W Z Y Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzyz (&rest rest435)

macro. reorder arguments (X Y Z W) as (W Z Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzz (&rest rest555)

macro. reorder arguments (X Y Z W) as (W Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzzw (&rest rest360)

macro. reorder arguments (X Y Z W) as (W Z Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzzx (&rest rest405)

macro. reorder arguments (X Y Z W) as (W Z Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fwzzy (&rest rest390)

macro. reorder arguments (X Y Z W) as (W Z Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fwzzz (&rest rest375)

macro. reorder arguments (X Y Z W) as (W Z Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fx (&rest rest5085)

macro. reorder arguments (X Y Z W) as (X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxw (&rest rest4980)

macro. reorder arguments (X Y Z W) as (X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxww (&rest rest4020)

macro. reorder arguments (X Y Z W) as (X W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwww (&rest rest3780)

macro. reorder arguments (X Y Z W) as (X W W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwwx (&rest rest3825)

macro. reorder arguments (X Y Z W) as (X W W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwwy (&rest rest3810)

macro. reorder arguments (X Y Z W) as (X W W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxwwz (&rest rest3795)

macro. reorder arguments (X Y Z W) as (X W W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwx (&rest rest4065)

macro. reorder arguments (X Y Z W) as (X W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwxw (&rest rest3960)

macro. reorder arguments (X Y Z W) as (X W X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwxx (&rest rest4005)

macro. reorder arguments (X Y Z W) as (X W X X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwxy (&rest rest3990)

macro. reorder arguments (X Y Z W) as (X W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxwxz (&rest rest3975)

macro. reorder arguments (X Y Z W) as (X W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwy (&rest rest4050)

macro. reorder arguments (X Y Z W) as (X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxwyw (&rest rest3900)

macro. reorder arguments (X Y Z W) as (X W Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxwyx (&rest rest3945)

macro. reorder arguments (X Y Z W) as (X W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxwyy (&rest rest3930)

macro. reorder arguments (X Y Z W) as (X W Y Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxwyz (&rest rest3915)

macro. reorder arguments (X Y Z W) as (X W Y Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fxwz (&rest rest4035)

macro. reorder arguments (X Y Z W) as (X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwzw (&rest rest3840)

macro. reorder arguments (X Y Z W) as (X W Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwzx (&rest rest3885)

macro. reorder arguments (X Y Z W) as (X W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxwzy (&rest rest3870)

macro. reorder arguments (X Y Z W) as (X W Z Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fxwzz (&rest rest3855)

macro. reorder arguments (X Y Z W) as (X W Z Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxx (&rest rest5025)

macro. reorder arguments (X Y Z W) as (X X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxw (&rest rest4920)

macro. reorder arguments (X Y Z W) as (X X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxww (&rest rest4680)

macro. reorder arguments (X Y Z W) as (X X W W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxwx (&rest rest4725)

macro. reorder arguments (X Y Z W) as (X X W X), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxwy (&rest rest4710)

macro. reorder arguments (X Y Z W) as (X X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxxwz (&rest rest4695)

macro. reorder arguments (X Y Z W) as (X X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxx (&rest rest4965)

macro. reorder arguments (X Y Z W) as (X X X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxxw (&rest rest4860)

macro. reorder arguments (X Y Z W) as (X X X W), (IGNORE Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxxx (&rest rest4905)

macro. reorder arguments (X Y Z W) as (X X X X), (IGNORE W Z Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxxy (&rest rest4890)

macro. reorder arguments (X Y Z W) as (X X X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxxxz (&rest rest4875)

macro. reorder arguments (X Y Z W) as (X X X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxy (&rest rest4950)

macro. reorder arguments (X Y Z W) as (X X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxxyw (&rest rest4800)

macro. reorder arguments (X Y Z W) as (X X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxxyx (&rest rest4845)

macro. reorder arguments (X Y Z W) as (X X Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxxyy (&rest rest4830)

macro. reorder arguments (X Y Z W) as (X X Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxxyz (&rest rest4815)

macro. reorder arguments (X Y Z W) as (X X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxxz (&rest rest4935)

macro. reorder arguments (X Y Z W) as (X X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxzw (&rest rest4740)

macro. reorder arguments (X Y Z W) as (X X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxzx (&rest rest4785)

macro. reorder arguments (X Y Z W) as (X X Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxxzy (&rest rest4770)

macro. reorder arguments (X Y Z W) as (X X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxxzz (&rest rest4755)

macro. reorder arguments (X Y Z W) as (X X Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxy (&rest rest5010)

macro. reorder arguments (X Y Z W) as (X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyw (&rest rest4620)

macro. reorder arguments (X Y Z W) as (X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyww (&rest rest4380)

macro. reorder arguments (X Y Z W) as (X Y W W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxywx (&rest rest4425)

macro. reorder arguments (X Y Z W) as (X Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxywy (&rest rest4410)

macro. reorder arguments (X Y Z W) as (X Y W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxywz (&rest rest4395)

macro. reorder arguments (X Y Z W) as (X Y W Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fxyx (&rest rest4665)

macro. reorder arguments (X Y Z W) as (X Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyxw (&rest rest4560)

macro. reorder arguments (X Y Z W) as (X Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyxx (&rest rest4605)

macro. reorder arguments (X Y Z W) as (X Y X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyxy (&rest rest4590)

macro. reorder arguments (X Y Z W) as (X Y X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyxz (&rest rest4575)

macro. reorder arguments (X Y Z W) as (X Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxyy (&rest rest4650)

macro. reorder arguments (X Y Z W) as (X Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyyw (&rest rest4500)

macro. reorder arguments (X Y Z W) as (X Y Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyyx (&rest rest4545)

macro. reorder arguments (X Y Z W) as (X Y Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyyy (&rest rest4530)

macro. reorder arguments (X Y Z W) as (X Y Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fxyyz (&rest rest4515)

macro. reorder arguments (X Y Z W) as (X Y Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxyz (&rest rest4635)

macro. reorder arguments (X Y Z W) as (X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxyzw (&rest rest4440)

macro. reorder arguments (X Y Z W) as (X Y Z W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fxyzx (&rest rest4485)

macro. reorder arguments (X Y Z W) as (X Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxyzy (&rest rest4470)

macro. reorder arguments (X Y Z W) as (X Y Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxyzz (&rest rest4455)

macro. reorder arguments (X Y Z W) as (X Y Z Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxz (&rest rest4995)

macro. reorder arguments (X Y Z W) as (X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzw (&rest rest4320)

macro. reorder arguments (X Y Z W) as (X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzww (&rest rest4080)

macro. reorder arguments (X Y Z W) as (X Z W W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzwx (&rest rest4125)

macro. reorder arguments (X Y Z W) as (X Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzwy (&rest rest4110)

macro. reorder arguments (X Y Z W) as (X Z W Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fxzwz (&rest rest4095)

macro. reorder arguments (X Y Z W) as (X Z W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzx (&rest rest4365)

macro. reorder arguments (X Y Z W) as (X Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzxw (&rest rest4260)

macro. reorder arguments (X Y Z W) as (X Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzxx (&rest rest4305)

macro. reorder arguments (X Y Z W) as (X Z X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzxy (&rest rest4290)

macro. reorder arguments (X Y Z W) as (X Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxzxz (&rest rest4275)

macro. reorder arguments (X Y Z W) as (X Z X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzy (&rest rest4350)

macro. reorder arguments (X Y Z W) as (X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxzyw (&rest rest4200)

macro. reorder arguments (X Y Z W) as (X Z Y W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fxzyx (&rest rest4245)

macro. reorder arguments (X Y Z W) as (X Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxzyy (&rest rest4230)

macro. reorder arguments (X Y Z W) as (X Z Y Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxzyz (&rest rest4215)

macro. reorder arguments (X Y Z W) as (X Z Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxzz (&rest rest4335)

macro. reorder arguments (X Y Z W) as (X Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzzw (&rest rest4140)

macro. reorder arguments (X Y Z W) as (X Z Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzzx (&rest rest4185)

macro. reorder arguments (X Y Z W) as (X Z Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fxzzy (&rest rest4170)

macro. reorder arguments (X Y Z W) as (X Z Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fxzzz (&rest rest4155)

macro. reorder arguments (X Y Z W) as (X Z Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fy (&rest rest5070)

macro. reorder arguments (X Y Z W) as (Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyw (&rest rest3720)

macro. reorder arguments (X Y Z W) as (Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyww (&rest rest2760)

macro. reorder arguments (X Y Z W) as (Y W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fywww (&rest rest2520)

macro. reorder arguments (X Y Z W) as (Y W W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fywwx (&rest rest2565)

macro. reorder arguments (X Y Z W) as (Y W W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fywwy (&rest rest2550)

macro. reorder arguments (X Y Z W) as (Y W W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fywwz (&rest rest2535)

macro. reorder arguments (X Y Z W) as (Y W W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fywx (&rest rest2805)

macro. reorder arguments (X Y Z W) as (Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fywxw (&rest rest2700)

macro. reorder arguments (X Y Z W) as (Y W X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fywxx (&rest rest2745)

macro. reorder arguments (X Y Z W) as (Y W X X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fywxy (&rest rest2730)

macro. reorder arguments (X Y Z W) as (Y W X Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fywxz (&rest rest2715)

macro. reorder arguments (X Y Z W) as (Y W X Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fywy (&rest rest2790)

macro. reorder arguments (X Y Z W) as (Y W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fywyw (&rest rest2640)

macro. reorder arguments (X Y Z W) as (Y W Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fywyx (&rest rest2685)

macro. reorder arguments (X Y Z W) as (Y W Y X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fywyy (&rest rest2670)

macro. reorder arguments (X Y Z W) as (Y W Y Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fywyz (&rest rest2655)

macro. reorder arguments (X Y Z W) as (Y W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fywz (&rest rest2775)

macro. reorder arguments (X Y Z W) as (Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fywzw (&rest rest2580)

macro. reorder arguments (X Y Z W) as (Y W Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fywzx (&rest rest2625)

macro. reorder arguments (X Y Z W) as (Y W Z X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fywzy (&rest rest2610)

macro. reorder arguments (X Y Z W) as (Y W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fywzz (&rest rest2595)

macro. reorder arguments (X Y Z W) as (Y W Z Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyx (&rest rest3765)

macro. reorder arguments (X Y Z W) as (Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxw (&rest rest3660)

macro. reorder arguments (X Y Z W) as (Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxww (&rest rest3420)

macro. reorder arguments (X Y Z W) as (Y X W W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxwx (&rest rest3465)

macro. reorder arguments (X Y Z W) as (Y X W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxwy (&rest rest3450)

macro. reorder arguments (X Y Z W) as (Y X W Y), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxwz (&rest rest3435)

macro. reorder arguments (X Y Z W) as (Y X W Z), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fyxx (&rest rest3705)

macro. reorder arguments (X Y Z W) as (Y X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxxw (&rest rest3600)

macro. reorder arguments (X Y Z W) as (Y X X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxxx (&rest rest3645)

macro. reorder arguments (X Y Z W) as (Y X X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxxy (&rest rest3630)

macro. reorder arguments (X Y Z W) as (Y X X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxxz (&rest rest3615)

macro. reorder arguments (X Y Z W) as (Y X X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyxy (&rest rest3690)

macro. reorder arguments (X Y Z W) as (Y X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxyw (&rest rest3540)

macro. reorder arguments (X Y Z W) as (Y X Y W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxyx (&rest rest3585)

macro. reorder arguments (X Y Z W) as (Y X Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxyy (&rest rest3570)

macro. reorder arguments (X Y Z W) as (Y X Y Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyxyz (&rest rest3555)

macro. reorder arguments (X Y Z W) as (Y X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyxz (&rest rest3675)

macro. reorder arguments (X Y Z W) as (Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyxzw (&rest rest3480)

macro. reorder arguments (X Y Z W) as (Y X Z W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fyxzx (&rest rest3525)

macro. reorder arguments (X Y Z W) as (Y X Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyxzy (&rest rest3510)

macro. reorder arguments (X Y Z W) as (Y X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyxzz (&rest rest3495)

macro. reorder arguments (X Y Z W) as (Y X Z Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyy (&rest rest3750)

macro. reorder arguments (X Y Z W) as (Y Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyw (&rest rest3360)

macro. reorder arguments (X Y Z W) as (Y Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyww (&rest rest3120)

macro. reorder arguments (X Y Z W) as (Y Y W W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyywx (&rest rest3165)

macro. reorder arguments (X Y Z W) as (Y Y W X), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyywy (&rest rest3150)

macro. reorder arguments (X Y Z W) as (Y Y W Y), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyywz (&rest rest3135)

macro. reorder arguments (X Y Z W) as (Y Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyx (&rest rest3405)

macro. reorder arguments (X Y Z W) as (Y Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyyxw (&rest rest3300)

macro. reorder arguments (X Y Z W) as (Y Y X W), (IGNORE Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyyxx (&rest rest3345)

macro. reorder arguments (X Y Z W) as (Y Y X X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyyxy (&rest rest3330)

macro. reorder arguments (X Y Z W) as (Y Y X Y), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyyxz (&rest rest3315)

macro. reorder arguments (X Y Z W) as (Y Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyyy (&rest rest3390)

macro. reorder arguments (X Y Z W) as (Y Y Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyyw (&rest rest3240)

macro. reorder arguments (X Y Z W) as (Y Y Y W), (IGNORE Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyyx (&rest rest3285)

macro. reorder arguments (X Y Z W) as (Y Y Y X), (IGNORE W Z).

Package

veq.

Source

select-dim.lisp.

Macro: fyyyy (&rest rest3270)

macro. reorder arguments (X Y Z W) as (Y Y Y Y), (IGNORE W Z X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyyz (&rest rest3255)

macro. reorder arguments (X Y Z W) as (Y Y Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyz (&rest rest3375)

macro. reorder arguments (X Y Z W) as (Y Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyzw (&rest rest3180)

macro. reorder arguments (X Y Z W) as (Y Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyzx (&rest rest3225)

macro. reorder arguments (X Y Z W) as (Y Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyyzy (&rest rest3210)

macro. reorder arguments (X Y Z W) as (Y Y Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyyzz (&rest rest3195)

macro. reorder arguments (X Y Z W) as (Y Y Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyz (&rest rest3735)

macro. reorder arguments (X Y Z W) as (Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzw (&rest rest3060)

macro. reorder arguments (X Y Z W) as (Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzww (&rest rest2820)

macro. reorder arguments (X Y Z W) as (Y Z W W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzwx (&rest rest2865)

macro. reorder arguments (X Y Z W) as (Y Z W X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fyzwy (&rest rest2850)

macro. reorder arguments (X Y Z W) as (Y Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzwz (&rest rest2835)

macro. reorder arguments (X Y Z W) as (Y Z W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzx (&rest rest3105)

macro. reorder arguments (X Y Z W) as (Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyzxw (&rest rest3000)

macro. reorder arguments (X Y Z W) as (Y Z X W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fyzxx (&rest rest3045)

macro. reorder arguments (X Y Z W) as (Y Z X X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyzxy (&rest rest3030)

macro. reorder arguments (X Y Z W) as (Y Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyzxz (&rest rest3015)

macro. reorder arguments (X Y Z W) as (Y Z X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyzy (&rest rest3090)

macro. reorder arguments (X Y Z W) as (Y Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzyw (&rest rest2940)

macro. reorder arguments (X Y Z W) as (Y Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzyx (&rest rest2985)

macro. reorder arguments (X Y Z W) as (Y Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyzyy (&rest rest2970)

macro. reorder arguments (X Y Z W) as (Y Z Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzyz (&rest rest2955)

macro. reorder arguments (X Y Z W) as (Y Z Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzz (&rest rest3075)

macro. reorder arguments (X Y Z W) as (Y Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzzw (&rest rest2880)

macro. reorder arguments (X Y Z W) as (Y Z Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzzx (&rest rest2925)

macro. reorder arguments (X Y Z W) as (Y Z Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fyzzy (&rest rest2910)

macro. reorder arguments (X Y Z W) as (Y Z Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fyzzz (&rest rest2895)

macro. reorder arguments (X Y Z W) as (Y Z Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fz (&rest rest5055)

macro. reorder arguments (X Y Z W) as (Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzw (&rest rest2460)

macro. reorder arguments (X Y Z W) as (Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzww (&rest rest1500)

macro. reorder arguments (X Y Z W) as (Z W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwww (&rest rest1260)

macro. reorder arguments (X Y Z W) as (Z W W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwwx (&rest rest1305)

macro. reorder arguments (X Y Z W) as (Z W W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzwwy (&rest rest1290)

macro. reorder arguments (X Y Z W) as (Z W W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwwz (&rest rest1275)

macro. reorder arguments (X Y Z W) as (Z W W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwx (&rest rest1545)

macro. reorder arguments (X Y Z W) as (Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzwxw (&rest rest1440)

macro. reorder arguments (X Y Z W) as (Z W X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzwxx (&rest rest1485)

macro. reorder arguments (X Y Z W) as (Z W X X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzwxy (&rest rest1470)

macro. reorder arguments (X Y Z W) as (Z W X Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fzwxz (&rest rest1455)

macro. reorder arguments (X Y Z W) as (Z W X Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzwy (&rest rest1530)

macro. reorder arguments (X Y Z W) as (Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwyw (&rest rest1380)

macro. reorder arguments (X Y Z W) as (Z W Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwyx (&rest rest1425)

macro. reorder arguments (X Y Z W) as (Z W Y X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fzwyy (&rest rest1410)

macro. reorder arguments (X Y Z W) as (Z W Y Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwyz (&rest rest1395)

macro. reorder arguments (X Y Z W) as (Z W Y Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwz (&rest rest1515)

macro. reorder arguments (X Y Z W) as (Z W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwzw (&rest rest1320)

macro. reorder arguments (X Y Z W) as (Z W Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwzx (&rest rest1365)

macro. reorder arguments (X Y Z W) as (Z W Z X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzwzy (&rest rest1350)

macro. reorder arguments (X Y Z W) as (Z W Z Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzwzz (&rest rest1335)

macro. reorder arguments (X Y Z W) as (Z W Z Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzx (&rest rest2505)

macro. reorder arguments (X Y Z W) as (Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxw (&rest rest2400)

macro. reorder arguments (X Y Z W) as (Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxww (&rest rest2160)

macro. reorder arguments (X Y Z W) as (Z X W W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxwx (&rest rest2205)

macro. reorder arguments (X Y Z W) as (Z X W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxwy (&rest rest2190)

macro. reorder arguments (X Y Z W) as (Z X W Y), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fzxwz (&rest rest2175)

macro. reorder arguments (X Y Z W) as (Z X W Z), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxx (&rest rest2445)

macro. reorder arguments (X Y Z W) as (Z X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxxw (&rest rest2340)

macro. reorder arguments (X Y Z W) as (Z X X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxxx (&rest rest2385)

macro. reorder arguments (X Y Z W) as (Z X X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxxy (&rest rest2370)

macro. reorder arguments (X Y Z W) as (Z X X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzxxz (&rest rest2355)

macro. reorder arguments (X Y Z W) as (Z X X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxy (&rest rest2430)

macro. reorder arguments (X Y Z W) as (Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzxyw (&rest rest2280)

macro. reorder arguments (X Y Z W) as (Z X Y W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fzxyx (&rest rest2325)

macro. reorder arguments (X Y Z W) as (Z X Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzxyy (&rest rest2310)

macro. reorder arguments (X Y Z W) as (Z X Y Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzxyz (&rest rest2295)

macro. reorder arguments (X Y Z W) as (Z X Y Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzxz (&rest rest2415)

macro. reorder arguments (X Y Z W) as (Z X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxzw (&rest rest2220)

macro. reorder arguments (X Y Z W) as (Z X Z W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxzx (&rest rest2265)

macro. reorder arguments (X Y Z W) as (Z X Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzxzy (&rest rest2250)

macro. reorder arguments (X Y Z W) as (Z X Z Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzxzz (&rest rest2235)

macro. reorder arguments (X Y Z W) as (Z X Z Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzy (&rest rest2490)

macro. reorder arguments (X Y Z W) as (Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyw (&rest rest2100)

macro. reorder arguments (X Y Z W) as (Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyww (&rest rest1860)

macro. reorder arguments (X Y Z W) as (Z Y W W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzywx (&rest rest1905)

macro. reorder arguments (X Y Z W) as (Z Y W X), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fzywy (&rest rest1890)

macro. reorder arguments (X Y Z W) as (Z Y W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzywz (&rest rest1875)

macro. reorder arguments (X Y Z W) as (Z Y W Z), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyx (&rest rest2145)

macro. reorder arguments (X Y Z W) as (Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzyxw (&rest rest2040)

macro. reorder arguments (X Y Z W) as (Z Y X W), (IGNORE).

Package

veq.

Source

select-dim.lisp.

Macro: fzyxx (&rest rest2085)

macro. reorder arguments (X Y Z W) as (Z Y X X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzyxy (&rest rest2070)

macro. reorder arguments (X Y Z W) as (Z Y X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzyxz (&rest rest2055)

macro. reorder arguments (X Y Z W) as (Z Y X Z), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzyy (&rest rest2130)

macro. reorder arguments (X Y Z W) as (Z Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyyw (&rest rest1980)

macro. reorder arguments (X Y Z W) as (Z Y Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyyx (&rest rest2025)

macro. reorder arguments (X Y Z W) as (Z Y Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzyyy (&rest rest2010)

macro. reorder arguments (X Y Z W) as (Z Y Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyyz (&rest rest1995)

macro. reorder arguments (X Y Z W) as (Z Y Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyz (&rest rest2115)

macro. reorder arguments (X Y Z W) as (Z Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyzw (&rest rest1920)

macro. reorder arguments (X Y Z W) as (Z Y Z W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyzx (&rest rest1965)

macro. reorder arguments (X Y Z W) as (Z Y Z X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzyzy (&rest rest1950)

macro. reorder arguments (X Y Z W) as (Z Y Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzyzz (&rest rest1935)

macro. reorder arguments (X Y Z W) as (Z Y Z Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzz (&rest rest2475)

macro. reorder arguments (X Y Z W) as (Z Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzw (&rest rest1800)

macro. reorder arguments (X Y Z W) as (Z Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzww (&rest rest1560)

macro. reorder arguments (X Y Z W) as (Z Z W W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzwx (&rest rest1605)

macro. reorder arguments (X Y Z W) as (Z Z W X), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzzwy (&rest rest1590)

macro. reorder arguments (X Y Z W) as (Z Z W Y), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzwz (&rest rest1575)

macro. reorder arguments (X Y Z W) as (Z Z W Z), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzx (&rest rest1845)

macro. reorder arguments (X Y Z W) as (Z Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzzxw (&rest rest1740)

macro. reorder arguments (X Y Z W) as (Z Z X W), (IGNORE Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzzxx (&rest rest1785)

macro. reorder arguments (X Y Z W) as (Z Z X X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzzxy (&rest rest1770)

macro. reorder arguments (X Y Z W) as (Z Z X Y), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzzxz (&rest rest1755)

macro. reorder arguments (X Y Z W) as (Z Z X Z), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzzy (&rest rest1830)

macro. reorder arguments (X Y Z W) as (Z Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzyw (&rest rest1680)

macro. reorder arguments (X Y Z W) as (Z Z Y W), (IGNORE X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzyx (&rest rest1725)

macro. reorder arguments (X Y Z W) as (Z Z Y X), (IGNORE W).

Package

veq.

Source

select-dim.lisp.

Macro: fzzyy (&rest rest1710)

macro. reorder arguments (X Y Z W) as (Z Z Y Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzyz (&rest rest1695)

macro. reorder arguments (X Y Z W) as (Z Z Y Z), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzz (&rest rest1815)

macro. reorder arguments (X Y Z W) as (Z Z Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzzw (&rest rest1620)

macro. reorder arguments (X Y Z W) as (Z Z Z W), (IGNORE Y X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzzx (&rest rest1665)

macro. reorder arguments (X Y Z W) as (Z Z Z X), (IGNORE W Y).

Package

veq.

Source

select-dim.lisp.

Macro: fzzzy (&rest rest1650)

macro. reorder arguments (X Y Z W) as (Z Z Z Y), (IGNORE W X).

Package

veq.

Source

select-dim.lisp.

Macro: fzzzz (&rest rest1635)

macro. reorder arguments (X Y Z W) as (Z Z Z Z), (IGNORE W Y X).

Package

veq.

Source

select-dim.lisp.

Macro: in (&body body)
Package

veq.

Source

utils.lisp.

Macro: in* (&body body)
Package

veq.

Source

utils.lisp.

Macro: lst (&body body)

wrap (values ..) in (list ..)

Package

veq.

Source

macros.lisp.

Macro: mac (expr)

expand macro.

Package

veq.

Source

utils.lisp.

Macro: mac* (expr)

expand macro all.

Package

veq.

Source

utils.lisp.

Macro: mvb (&rest args)
Package

veq.

Source

utils.lisp.

Macro: mvc (&rest args)
Package

veq.

Source

utils.lisp.

Macro: mvcwrap (m fx)

wrap fx in a macro, m, so that fx will be called via mvc.

Package

veq.

Source

utils.lisp.

Macro: vdef (fname &body body)

define function with veq context enabled. uses vprogn.

Package

veq.

Source

macros.lisp.

Macro: vdef* (mname &body body)

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

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

Package

veq.

Source

macros.lisp.

Macro: vgrp-mvc ((dim fx) &body body)

do (multiple-value-call fx g) where g is groups of size dim over (values ...) returned by body.

Package

veq.

Source

utils.lisp.

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

wraps labels so that it can be used with implicit multiple value call (mvc). that is, all labels are defined as if with vdef* or fvdef*
use %labelname to call the function directly, not via mvc.

Package

veq.

Source

macros.lisp.

Macro: vpr (&rest rest)

print (mvc #’list rest) and return (mvc #’values rest).

Package

veq.

Source

utils.lisp.

Macro: vprod (&rest args)

(mvc #’* ...)

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).

fvprogn is faster, but has some limitations.

Package

veq.

Source

macros.lisp.

Macro: vsum (&rest args)

(mvc #’+ ...)

Package

veq.

Source

utils.lisp.

Macro: ~ (&rest rest)

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

Package

veq.

Source

macros.lisp.


5.1.4 Setf expanders

Setf Expander: (setf $) (a &optional i)

use (setf ($ a i) (list x)) to set a[i].

Package

veq.

Source

vset.lisp.

Setf Expander: (setf 2$) (a &optional i)

use (setf (2$ a i) (list x y)) to set a[i].

Package

veq.

Source

vset.lisp.

Setf Expander: (setf 3$) (a &optional i)

use (setf (3$ a i) (list x y z)) to set a[i].

Package

veq.

Source

vset.lisp.

Setf Expander: (setf 4$) (a &optional i)

use (setf (4$ a i) (list x y z w)) to set a[i].

Package

veq.

Source

vset.lisp.


Next: , Previous: , Up: Public Interface   [Contents][Index]

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 n dim)

pretty print nd array

Package

veq.

Source

array-print.lisp.

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

return array as a list of nd lists

Package

veq.

Source

array-print.lisp.

Function: 2$num (a0)

number of elements in 2d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: 2$print (a &key n)

print 2d array

Package

veq.

Source

array-print.lisp.

Function: 2$to-list (a)

return array as a list of 2d lists

Package

veq.

Source

array-print.lisp.

Function: 3$num (a0)

number of elements in 3d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: 3$print (a &key n)

print 3d array

Package

veq.

Source

array-print.lisp.

Function: 3$to-list (a)

return array as a list of 3d lists

Package

veq.

Source

array-print.lisp.

Function: 4$num (a0)

number of elements in 4d array. untyped.

Package

veq.

Source

array-utils.lisp.

Function: 4$print (a &key n)

print 4d array

Package

veq.

Source

array-print.lisp.

Function: 4$to-list (a)

return array as a list of 4d lists

Package

veq.

Source

array-print.lisp.

Function: d$copy (a)

copy array

Package

veq.

Source

array-utils.lisp.

Function: d$last (a0)

get last row of 1d array as (values ...)

Package

veq.

Source

array-rows.lisp.

Function: d$mima (a0 &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-mima.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$sum (a &key n)

sum all rows of 1d array.

Package

veq.

Source

array-reduce.lisp.

Function: d$take (a inds &key res)

returns 1d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: d2$last (a0)

get last row of 2d array as (values ...)

Package

veq.

Source

array-rows.lisp.

Function: d2$mima (a0 &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-mima.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$sum (a &key n)

sum all rows of 2d array.

Package

veq.

Source

array-reduce.lisp.

Function: d2$take (a inds &key res)

returns 2d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 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)

get last row of 3d array as (values ...)

Package

veq.

Source

array-rows.lisp.

Function: d3$mima (a0 &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-mima.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$sum (a &key n)

sum all rows of 3d array.

Package

veq.

Source

array-reduce.lisp.

Function: d3$take (a inds &key res)

returns 3d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 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)

get last row of 4d array as (values ...)

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$sum (a &key n)

sum all rows of 4d array.

Package

veq.

Source

array-reduce.lisp.

Function: d4$take (a inds &key res)

returns 4d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 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

utils.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: dfl (l)

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

Package

veq.

Source

utils.lisp.

Function: f$copy (a)

copy array

Package

veq.

Source

array-utils.lisp.

Function: f$last (a0)

get last row of 1d array as (values ...)

Package

veq.

Source

array-rows.lisp.

Function: f$mima (a0 &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-mima.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$sum (a &key n)

sum all rows of 1d array.

Package

veq.

Source

array-reduce.lisp.

Function: f$take (a inds &key res)

returns 1d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 array of zeros. typed.

Package

veq.

Source

array-utils.lisp.

Function: f2$last (a0)

get last row of 2d array as (values ...)

Package

veq.

Source

array-rows.lisp.

Function: f2$mima (a0 &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-mima.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$sum (a &key n)

sum all rows of 2d array.

Package

veq.

Source

array-reduce.lisp.

Function: f2$take (a inds &key res)

returns 2d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 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)

get last row of 3d array as (values ...)

Package

veq.

Source

array-rows.lisp.

Function: f3$mima (a0 &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-mima.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$sum (a &key n)

sum all rows of 3d array.

Package

veq.

Source

array-reduce.lisp.

Function: f3$take (a inds &key res)

returns 3d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 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)

get last row of 4d array as (values ...)

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$sum (a &key n)

sum all rows of 4d array.

Package

veq.

Source

array-reduce.lisp.

Function: f4$take (a inds &key res)

returns 4d array with rows for inds. use :res put result in existing array

Package

veq.

Source

array-take.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 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)