cl-ana

API Reference

cl-ana

No packages.

cl-ana.binary-tree

Simple binary-tree implementation, not meant for high-performance code.

CL-ANA.BINARY-TREE

  • Function NODE-LEAF-P (node)
  • Function NODE-VALUE (tree)
  • Function NODE-LEFT-CHILD (tree)
  • Function NODE-RIGHT-CHILD (tree)
  • Function MAKE-BALANCED-TREE (list &key key sorted (comparison #'<) (test #'equal))
  • Function BREF (tree val &key (key #'identity))
    Returns a cons pair of node values which form the most constraining interval around val using key.

cl-ana.calculus

A few numerical and/or symbolic calculus functions.

CL-ANA.CALCULUS

  • Function DIFF (fn &key (prec 1.d-9))
    Returns the one-sided numerical derivative of a function.
  • Function NEWTON (fn guess &key (value 0) (maxtries 50) (prec 1.d-4) (diff-prec 1.d-9))
    1-D Newton's method for solving an equation. If the method converges, returns the values of x_sol, fn(x_sol), and the number of iterations it took to converge. If the method does not converge, returns the values of nil and the number of iterations on failure. value is the value that fn should evaluate to. maxtries is the maximum number of iterations to attempt a solution. prec is the precision in the residue, below which convergence is assumed. diff-prec is the precision to use in calculating the derivative of fn via diff.
  • Function INVERT (fn &key (guess-fn (constantly 1)) (newton-prec 1.d-4) (diff-prec 1.d-9))
    Inverts a function numerically using Newton's method. Returns the inverse function using the precision parameters given. guess-fn is a function which evaluates to a guess value for each input value to the inverse function to use in Newton's method. newton-prec is the precision argument to give to Newton's method for the precision in the residue of the result. diff-prec is the precision to give to diff during Newton's method.

cl-ana.clos-utils

clos-utils provides various lacking utilities for working with structures and CLOS class instances as well as utilities for transforming them into clists which can be written/read with standard stream objects portably.

CL-ANA.CLOS-UTILS

  • Function SLOT-NAMES (obj)
    Returns the list of slot symbols for a structure/CLOS class instance.
  • Function SLOT-KEYWORD-NAMES (obj)
  • Function SLOT-VALUES (obj)
    Returns a list of the slot values in a structure/CLOS class instance.
  • Function CLIST-TYPE (clist)
    Returns the type symbol for the type of the object the clist represents.
  • Function CLIST-FIELD-SYMBOLS (clist)
    Returns the field symbols for the object the clist represents.
  • Function CLIST-FIELD-VALUES (clist)
  • Function OBJECT->CLIST (obj)
    Returns a clist for the object obj. Supports structures/CLOS classes, arbitrary cons structures, nested sequences of any structure; all other objects are returned as-is.
  • Function OBJECT->PLIST (obj)
    Returns a plist for the object obj.
  • Function CLIST->OBJECT (clist)
    Currently only works for one-level-deep clists; needs to be fixed to allow arbitrary depth.
  • Generic-Function TYPE-CONSTRUCTOR (object)
    Returns the function responsible for constructing objects of the same type as the object. Default value is nil unless a method is defined for an object/type.
  • Method TYPE-CONSTRUCTOR (obj)
  • Method TYPE-CONSTRUCTOR (obj)
  • Method TYPE-CONSTRUCTOR (obj)

cl-ana.csv-table

No packages.

cl-ana.error-propogation

Implements error propogation inside the generic-math framework.

CL-ANA.ERROR-PROPOGATION

  • Class ERR-NUM
    VAL   Accessor: ERR-NUM-VALUE
    ERR   Accessor: ERR-NUM-ERROR
  • Function +- (&rest val-errs)
    Constructs a numerical value along with errors. Note that the structure allows for errors in errors to arbitrary depth.
  • Function ERR-NUM-+ (&rest err-nums)
  • Function ERR-NUM-- (&rest err-nums)
  • Function ERR-NUM-* (&rest err-nums)
  • Function ERR-NUM-/ (&rest err-nums)

cl-ana.file-utils

Various utilities for working with files

CL-ANA.FILE-UTILS

  • Function READ-LINES-FROM-FILE (file)
  • Function READ-LINES-FROM-PATHNAME (pathname)
  • Function READ-FIELDS-FROM-FILE (file)
  • Function READ-FIELDS-FROM-PATHNAME (pathname)
  • Function WRITE-LINES-TO-FILE (lines file)
  • Function WRITE-LINES-TO-PATHNAME (lines pathname &key if-exists if-does-not-exist)
  • Function FILE-LAST-CHANGED (pathname-or-string)
    Returns time in seconds since epoch of when the file data was changed.

cl-ana.fitting

No packages.

cl-ana.functional-utils

Utilities for doing functional programming not already provided by Alexandria.

CL-ANA.FUNCTIONAL-UTILS

  • Function FLIP (f)
    Takes a function of two parameters and creates a new function which takes the same parameters in reverse order; particularly useful in conjunction with reduce.
  • Function SPLICE (xsplit fn1 fn2)
    Splices two functions togother at xsplit. If either function is nil, returns the other function or nil if both are nil.
  • Function TO-PAIR-FUNCTION (f)
    Makes f apply to a pair instead of two arguments
  • Function LFUNCALL (fn &rest args)
    Applies a function which takes a single list argument to an arbitrary number of arguments.
  • Function MIN-BY (x y &key (key #'identity))
  • Function MINIMUM (xs &key (key #'identity))
  • Function MAX-BY (x y &key (key #'identity))
  • Function MAXIMUM (xs &key (key #'identity))
  • Function ITERATE (fn initial count)
    Calls a function on its own result for count iterations. Returns the final result.
  • Function ITERATE-COLLECT (fn initial count)
    Calls a function on its own result for count iterations. Returns the full list of results.

cl-ana.generic-math

Provides generic versions of (most ATM) the standard Common Lisp math functions; this allows easy extension to new mathematical objects.

CL-ANA.GENERIC-MATH

  • Function USE-GMATH (package)
    shadowing-imports all the exported symbols from gmath into the current package
  • Variable *GMATH-GENERIC-MAP*
    (make-hash-table :test 'equal)
    Hash table mapping generic function symbols to the argument specification for the function.
  • Macro DEFMATH (fname (&rest args) &body body)
    Defines a generic function for use in generic-math. Necessary to allow for programmatically generated methods of certain mathematical types. Can use body just like with defgeneric to specify methods etc.
  • Macro DEFMETHOD-COMMUTATIVE (method-name (left-arg right-arg) &body body)
  • Macro INCF (place &optional (delta 1))
  • Macro DECF (place &optional (delta 1))
  • Function + (&rest xs)
  • Function SUM (xs)
    Convenience function for summing a list of values (it's reducing + across them).
  • Function PRODUCT (xs)
    Convenience function for multiplying a list of values
  • Generic-Function ADD (x y)
    Binary addition function
  • Function - (&rest xs)
  • Generic-Function SUB (x y)
    Binary subtraction function
  • Generic-Function UNARY-SUB (x)
    Unary subtraction function.
  • Function * (&rest xs)
  • Generic-Function MULT (x y)
    Binary multiplication function
  • Function / (&rest xs)
  • Function PROTECTED-/ (&rest xs)
  • Generic-Function DIV (x y)
    Binary division function
  • Generic-Function UNARY-DIV (x)
    Unary division function. Also known as multiplicative inversion.
  • Generic-Function PROTECTED-DIV (x y &key protected-value)
    Binary division protected from division by zero; returns protected-value whenever y is zero
  • Method PROTECTED-DIV (x y &key (protected-value 0))
  • Method PROTECTED-DIV (x y &key (protected-value 0))
  • Method PROTECTED-DIV (x y &key (protected-value 0))
  • Generic-Function PROTECTED-UNARY-DIV (x &key protected-value)
    Protected unary division function. Returns protected-value whenever x is zero.
  • Method PROTECTED-UNARY-DIV (x &key (protected-value 0))
  • Method PROTECTED-UNARY-DIV (x &key (protected-value 0))
  • Method PROTECTED-UNARY-DIV (x &key (protected-value 0))
  • Generic-Function SQRT (x)
    Square root function
  • Generic-Function EXPT (x y)
    Raises x to the y power
  • Generic-Function EXP (x)
    e^x
  • Generic-Function LOG (x)
    Natural logarithm function
  • Generic-Function SIN (x)
    Sine, in radians
  • Generic-Function COS (x)
    Cosine, in radians
  • Generic-Function TAN (x)
    Tangent, in radians
  • Generic-Function SEC (x)
    Secant, in radians
  • Method SEC (x)
  • Method SEC (x)
  • Method SEC (x)
  • Generic-Function CSC (x)
    Cosecant, in radians
  • Method CSC (x)
  • Method CSC (x)
  • Method CSC (x)
  • Generic-Function COT (x)
    Cotangent, in radians
  • Method COT (x)
  • Method COT (x)
  • Method COT (x)
  • Generic-Function SINH (x)
    Hyperbolic sine function
  • Generic-Function COSH (x)
    Hyperbolic cosine function
  • Generic-Function TANH (x)
    Hyperbolic tangent function
  • Generic-Function SECH (x)
    Hyperbolic secant function
  • Method SECH (x)
  • Method SECH (x)
  • Method SECH (x)
  • Generic-Function CSCH (x)
    Hyperbolic cosecant function
  • Method CSCH (x)
  • Method CSCH (x)
  • Method CSCH (x)
  • Generic-Function COTH (x)
    Hyperbolic cotangent function
  • Method COTH (x)
  • Method COTH (x)
  • Method COTH (x)
  • Method ADD ((x number) (y number))
  • Method SUB ((x number) (y number))
  • Method UNARY-SUB ((x number))
  • Method MULT ((x number) (y number))
  • Method DIV ((x number) (y number))
  • Method UNARY-DIV ((x number))
  • Method PROTECTED-DIV (x (y number) &key (protected-value 0))
  • Method PROTECTED-UNARY-DIV ((x number) &key (protected-value 0))
  • Method SQRT ((x number))
  • Method EXPT ((x number) (y number))
  • Method EXP ((x number))
  • Method LOG ((x number))
  • Method SIN ((x number))
  • Method COS ((x number))
  • Method TAN ((x number))
  • Method SINH ((x number))
  • Method COSH ((x number))
  • Method TANH ((x number))

cl-ana.gnuplot-interface

Interface for spawning & communicating with gnuplot sessions from LISP.

CL-ANA.GNUPLOT-INTERFACE

  • Function GNUPLOT-INIT
  • Function GNUPLOT-CLOSE (session)
  • Function GNUPLOT-CMD (session command-string)

cl-ana.gsl-cffi

Functions for interfacing with GSL which don't seem to work/aren't currently provided through GSLL.

CL-ANA.GSL-CFFI

  • Variable +GSL-EOF+
    32
    End-of-file return value for gsl functions

cl-ana.hash-table-utils

Utilities for working with hash tables

CL-ANA.HASH-TABLE-UTILS

  • Function HASH-TABLE->ALIST (hash-table)
  • Function HASH-KEYS (hash-table)
  • Function HASH-VALUES (hash-table)
  • Function HMAP (fn hash-table)
    hmap is a more functional version of maphash; instead of returning nil and relying on mutable state, hmap returns a new hash table with the same keys but mapped values in the resulting hash table. fn is a function which takes a key and value from hash-table and returns an updated value for the resulting hash table.
  • Function ALIST->HASH-TABLE (alist &optional (test 'eql))

cl-ana.hdf-cffi

HDF5 cffi bindings

CL-ANA.HDF-CFFI

  • Cffi-Type SIZE-T
  • Cffi-Type HID-T
  • Cffi-Type HERR-T
  • Cffi-Type HSIZE-T
  • Cffi-Type HSSIZE-T
  • Cffi-Enum H5T-CLASS-T
  • Cffi-Enum H5T-DIRECTION-T
  • Cffi-Enum H5S-SELOPER-T
  • Variable +H5S-UNLIMITED+
    18446744073709551615
  • Variable +H5S-ALL+
    0
  • Variable +H5F-ACC-TRUNC+
    2
  • Variable +H5F-ACC-RDONLY+
    0
  • Variable +H5F-ACC-RDWR+
    1
  • Variable +H5P-DEFAULT+
    0
  • Variable +H5P-DATASET-CREATE+
    150994953
  • Variable +H5T-NATIVE-CHAR+
    50331656
  • Variable +H5T-NATIVE-UCHAR+
    50331657
  • Variable +H5T-NATIVE-SHORT+
    50331658
  • Variable +H5T-NATIVE-USHORT+
    50331659
  • Variable +H5T-NATIVE-INT+
    50331660
  • Variable +H5T-NATIVE-UINT+
    50331661
  • Variable +H5T-NATIVE-LONG+
    50331662
  • Variable +H5T-NATIVE-ULONG+
    50331663
  • Variable +H5T-NATIVE-LLONG+
    50331688
  • Variable +H5T-NATIVE-ULLONG+
    50331689
  • Variable +H5T-NATIVE-FLOAT+
    50331690
  • Variable +H5T-NATIVE-DOUBLE+
    50331691
  • Variable +H5T-COMPOUND+
    6
  • Variable +H5F-OBJ-FILE+
    1
  • Variable +H5F-OBJ-DATASET+
    2
  • Variable +H5F-OBJ-GROUP+
    4
  • Variable +H5F-OBJ-DATATYPE+
    8
  • Variable +H5F-OBJ-ATTR+
    16
  • Variable +H5F-OBJ-ALL+
    31
  • Variable *HDF-CFFI-TYPE-MAP*
    (list (cons cl-ana.hdf-cffi:+h5t-native-char+ :char)
          (cons cl-ana.hdf-cffi:+h5t-native-uchar+ :uchar)
          (cons cl-ana.hdf-cffi:+h5t-native-short+ :short)
          (cons cl-ana.hdf-cffi:+h5t-native-ushort+ :ushort)
          (cons cl-ana.hdf-cffi:+h5t-native-int+ :int)
          (cons cl-ana.hdf-cffi:+h5t-native-uint+ :uint)
          (cons cl-ana.hdf-cffi:+h5t-native-llong+ :long-long)
          (cons cl-ana.hdf-cffi:+h5t-native-ullong+ :ullong)
          (cons cl-ana.hdf-cffi:+h5t-native-float+ :float)
          (cons cl-ana.hdf-cffi:+h5t-native-double+ :double))
  • Function CFFI-NATIVE-TYPE (hdf-native-type)
  • Function HDF-NATIVE-TYPE (cffi-native-type)

cl-ana.hdf-table

Table subclass specializing on HDF5 datasets

CL-ANA.HDF-TABLE

  • Class HDF-TABLE  (TYPED-TABLE)
    ROW-BUFFER-SIZE   Accessor: HDF-TABLE-BUFFER-SIZE
    buffer size in number of rows
    CHUNK-INDEX   Accessor: HDF-TABLE-CHUNK-INDEX
    index to the in-memory chunk
    ROW-BUFFER   Accessor: HDF-TABLE-ROW-BUFFER
    Object for storing a row to be read from/written to hdf table. It's stored as part of the table for efficiency purposes and should not be handled directly by the user; use the awesome higher level tools for that.
    ROW-BUFFER-INDEX   Accessor: HDF-TABLE-ROW-BUFFER-INDEX
    Index to the row in the buffer which is currently being modified prior to writing.
    HDF-DATASET   Accessor: HDF-TABLE-DATASET
    hdf dataset which the table is reading from/writing to.
    HDF-ROW-TYPE   Accessor: HDF-TABLE-ROW-TYPE
    hdf type for the row data object
    READ-ROW-INDEX   Accessor: HDF-TABLE-READ-ROW-INDEX
    Index to row which should be sequentually read next
    NROWS   Accessor: HDF-TABLE-NROWS
    number of rows in hdf-table
  • Function OPEN-HDF-TABLE (hdf-file dataset-name &key buffer-size)
  • Function CREATE-HDF-TABLE (hdf-file dataset-path names-specs &key (buffer-size 1000))
    Creates a hdf-table for writing in hdf-file with dataset-path as the path to the dataset in the hdf-file and the alist names-specs which maps the field names to their typespecs (this is just applying rest to the typespec for the table). Buffer size will be used as both the chunksize for the hdf dataset and as the size of the buffer for writing into the file.
  • Class HDF-TABLE-CHAIN  (TABLE)
    DATASET-PATH   Accessor: HDF-TABLE-CHAIN-DATASET-PATH
    Path to dataset within each file. The path should be uniform if the hdf files truly are a chain.
    ACTIVE-TABLE   Accessor: HDF-TABLE-CHAIN-ACTIVE-TABLE
    The in-memory hdf-table
    ACTIVE-FILE   Accessor: HDF-TABLE-CHAIN-ACTIVE-FILE
    hdf-file currently opened by the active hdf-table.
    FILE-PATHS   Accessor: HDF-TABLE-CHAIN-FILE-PATHS
    List of file-paths which contain one hdf-table each
    TABLE-LENGTHS   Accessor: HDF-TABLE-CHAIN-TABLE-LENGTHS
    Length (in indices) of each table
    TABLE-INDEX-OFFSETS   Accessor: HDF-TABLE-CHAIN-TABLE-INDEX-OFFSETS
    Start indexes for each table
    CURRENT-TABLE-INDEX   Accessor: HDF-TABLE-CHAIN-CURRENT-TABLE-INDEX
    index for in-memory hdf-table in (virtual) list of tables
    CURRENT-TABLE-START   Accessor: HDF-TABLE-CHAIN-CURRENT-TABLE-START
    starting row index for the current table
    CURRENT-TABLE-END   Accessor: HDF-TABLE-CHAIN-CURRENT-TABLE-END
    last row index for the current table
    TABLE-INDEX-BINARY-TREE   Accessor: HDF-TABLE-CHAIN-BINARY-TREE
    binary search tree storing the indeces for efficient searching
    READ-ROW-INDEX   Accessor: HDF-TABLE-CHAIN-READ-ROW-INDEX
    Index to row which should be sequentually read next
    NROWS   Accessor: HDF-TABLE-CHAIN-NROWS
    number of rows in hdf-table
  • Function OPEN-HDF-TABLE-CHAIN (filename-list dataset-path)
    Creates and initializes hdf-table-chain given the filename-list and dataset-path

cl-ana.hdf-typespec

Utilities for creating/reading HDF5 types from/into typespecs.

CL-ANA.HDF-TYPESPEC

  • Function TYPESPEC->HDF-TYPE (&rest xs3)
  • Function HDF-TYPE->TYPESPEC (&rest xs135)

cl-ana.hdf-utils

Utilities for a more lispy interface to HDF5

CL-ANA.HDF-UTILS

  • Macro WITH-CLEANUP ((&rest specs) &body body)
    Executes body inside of a lexical environment where objects described by specs are bound and then freed upon concluding the body. Each spec is a list of 3 elements: 1. A symbol which will denote a variable inside the body, 2. A form which will be evaluated and its value bound to the symbol, 3. A function for cleaning up the object referenced by the symbol; it will be given the symbol as the sole argument.
  • Macro WITH-OPEN-DATASPACE ((dataspace dataset) &body body)
    Safely work with dataspace taken from dataset
  • Macro WITH-CREATE-DATASPACE ((dataspace rank dims maxdims) &body body)
    Creates a new dataspace and cleans up after it
  • Macro WITH-DATASET-TYPE ((type dataset) &body body)
  • Function OPEN-HDF-FILE (filename &key direction (if-exists nil if-exists-supplied-p) (if-does-not-exist nil if-does-not-exist-supplied-p) (read-access-parameters +h5p-default+) (write-access-parameters (list +h5p-default+ +h5p-default+)))
    Opens an hdf file, returning a handle to the file (hid-t). direction can be :input or :output. if-exists can be :supersede :error nil if-does-not-exist can be :create :error nil
  • Function CLOSE-HDF-FILE (hdf-file)
    Closes all datatype objects associated with file along with the file
  • Macro WITH-OPEN-HDF-FILE ((hdf-file file-path-or-string &key direction (if-exists nil if-exists-supplied-p) (if-does-not-exist nil if-does-not-exist-supplied-p) (read-access-parameters +h5p-default+) (write-access-parameters (list +h5p-default+ +h5p-default+))) &body body)
    Macro providing lispy access to hdf (HDF5) files. Use just like you would with-open-file, just give a file and a path/string. The usual key arguments for access mode, etc. are honored and transformed into HDF5 terms. The argument hdf-file is the symbol you'll use to refer to the file handle inside of the macro body.
  • Function HDF-MKGROUP (file group-name)
    Creates a group with name group-name in hdf-file file; returns path to group with final '/' included.

cl-ana.histogram

No packages.

cl-ana.int-char

For some reason my SBCL doesn't support int-char anymore, so here it is.

CL-ANA.INT-CHAR

  • Function INT-CHAR (integer)

cl-ana.linear-algebra

(minimal) Linear algebra library which is integrated into the generic math framework.

CL-ANA.LINEAR-ALGEBRA

  • Function MAKE-MATRIX (nrows ncols &key (initial-element 0.0d0))
  • Function MAKE-VECTOR (nelts &key (initial-element 0.0d0))
  • Function MATRIX-TRANSPOSE (matrix &optional (type 'vector))
  • Function VECTOR->MATRIX (vector &key (orientation :column) (type 'vector))
  • Function MATRIX-MULT (x y &optional (type 'vector))
  • Function EUCLIDEAN-DOT (x y)
  • Function EUCLIDEAN-NORM2 (x)
  • Function EUCLIDEAN-NORM (x)
  • Function PHI (vector)
  • Function THETA (vector)
  • Function CROSS-PRODUCT (a b)
    Returns cross product of vectors a and b

cl-ana.list-utils

Utilities for working with lists not already provided by Alexandria.

CL-ANA.LIST-UTILS

  • Function RANGE (start end &optional (step 1))
  • Function ZIP (x y)
  • Function LZIP (&rest lists)
    Like zip, but uses lists instead of cons pairs thus allowing ntuples
  • Function UNZIP (xs)
    Returns a cons with the car being the cars of the zipped xs and the cdr being the cdrs.
  • Function UNLZIP (xs)
    lzip is an inverse (through apply) of itself, simply applies lzip to its argument, returning a list of the previously zipped lists in xs.
  • Function MAPZIP (fn &rest lists)
    Returns an alist mapping the list of corresponding elements from each input list to the value of fn for those values; it's just zipping together the arguments with the value of fn. If only one list is given, the elements are mapped directly (i.e. not in a list)
  • Function TREE-MAP (fn &rest trees)
    Maps function over identically structured trees (lists)
  • Function INTERSPERSE (obj lst)
    Inserts obj in between each pair of elements in lst
  • Function TRANSPOSE (xs)
  • Function CARTESIAN-PRODUCT (&rest xs)
  • Function EVERY-NTH (list n &optional (start 0))
  • Function EXCEPT-NTH (x n)
  • Function AT-INDICES (lst indices)
    Returns the values from lst located at positions given by indices
  • Function EXCEPT-AT (xs ns &key (test #'eql) uniquely-sorted)
    Yields the list of xs except for the elements at the positions in ns. Set uniquely-sorted to t if you want except-at to assume the ns are already unique and sorted least to greatest.
  • Function COMPRESS (list &key (key #'identity) (test 'eql) sort-by singleton-pairs)
    Compress list such that duplicate elements are combined into a single pair entry which has as the car the element value and as the cdr the count. The singleton-pairs option controls whether single elements are still placed inside a pair. This is useful when the elements of the list you wish to compress are cons cells, as this would otherwise lead to ambiguity in the result.
  • Function LIST-LESS-THAN (list1 list2)
  • Function LIST-GREATER-THAN (list1 list2)
  • Function AREF-BY-LIST (array indexlist)
    Access array element via index list instead of individual indices
  • Function MAKE-OFFSETS (sizes)
    Takes a list of sizes and returns a list containing 0, (first sizes), (+ (first sizes) (second sizes)), ... summing the sizes as the list goes. This pattern has turned out to be recurrent, and the result can be interpreted as finding the starting index of the ith list in the concatenation of n lists.
  • Function CDRS (xs)
  • Function CARS (xs)
  • Function LIST->SET (list &optional (test #'eql))
    Returns list with duplicates removed
  • Function PARTITION (list &key (key #'identity) (test #'eql))
    Re-groups the contents of a list into partitions using the test function provided. Guarantees that the elements of each group pass test with every member of the partition as long as the test function is transitive. Does not necessarily preserve order of partitions, but preserves order of the elements relative to each partition. This function supports two different conceptual approaches to partitioning: * By relation: the test function is the equivalence relation operator * By association: using a key function which maps into a set of index values allows the user to partition according to association with that value.
  • Function LENGTH-EQUAL (list length)
    Returns t/nil as soon as it is apparent that the list does not contain exactly length elements.
  • Function SINGLE (list)
    Checks to see if list is a list with exactly one element.
  • Function APPEND1 (list object)
    Creates a list containing object and appends list to it.
  • Function CONC1 (list object)
    Like append1, but uses nconc instead of append
  • Function MKLIST (object)
    Ensures that object is a list, if not object is packaged in a list.
  • Macro ENSURE-LISTS ((&rest list-bindings) &body body)
    Ensures and rebinds variables as lists via mklist. Each list-binding must be either a symbol or a list (symbol form); for a symbol it will be bound to (mklist symbol) in the body; for a list the first element of the list-binding will be bound to (mklist (second list-binding)).
  • Function LONGER (x y)
    Efficiently compares two lists, or if they're not both lists simply calls length on each and compares. This could be sped up a bit if one argument is a list and the other not, so it's a work in progress.
  • Function GROUP (source n)
    Takes a list and returns a list of lists of the elements in the list grouped in lists of size n with the remainder in the last list.
  • Function PRUNE (test tree)
    Like remove-if, but for lists treated as trees.
  • Function FIND2 (fn list)
    Like find, but it returns two values: the list element and the value that fn returned.
  • Function BEFORE (x y list &key (test #'eql))
    Tells you if x is found before y in list.
  • Function AFTER (x y list &key (test #'eql))
    Tells you if x is found after y in list.
  • Function DUPLICATE (object list &key (test #'eql))
    Tells you if the object occurs more than once in the list.
  • Function PERMUTE (list permutation)
    Re-arranges the elements in list according to the permutation.
  • Function PLIST->ALIST (plist)
    Forms an alist from a plist
  • Function ALIST->PLIST (alist)
    Forms a plist from an alist
  • Function PLIST-SELECT-FIELDS (plist &rest fields)
    Returns a list of the fields from plist in the order specified; the element will be nil if the field is not present.
  • Macro DO-PLIST ((field-symbol field-value plist) &body body)
    Executes body via looping over plist, binding each field symbol to field-symbol and each field value to field-value. Returns nil.
  • Macro DO-PLISTS (plists &body body)
    Loops over a plist, binding each field in the plist to a variable of the same name as the field symbol but in the current package.

cl-ana.lorentz

Implements lorentz vectors, lorentz transformations, etc.

CL-ANA.LORENTZ

  • Function MINKOWSKI-DOT (left-vector right-vector)
    Computes the inner product using the Minkowski metric; only requires the tensor-ref function to be defined and that the vectors each have exactly 4 elements each.
  • Function MINKOWSKI-NORM (vector)
  • Function MINKOWSKI-NORM2 (vector)
  • Function MAKE-LORENTZ-BOOST (beta-vector)
    Construct lorentz boost matrix from beta vector
  • Function GAMMA (beta)
    Returns gamma factor from beta
  • Function GAMMA-FROM-BETA2 (beta2)
    Computes gamma from beta^2, for efficiency purposes
  • Function LORENTZ-VECTOR-SPATIAL (vector)
    Returns spatial part of the lorentz-vector
  • Function FOUR-MOMENTUM-BETA-VECTOR (four-momentum)
    Returns the beta vector from the four-momentum. Assumes that your units are chosen such that c is effectively 1 (e.g. GeV/c^2 for mass, GeV/c for momentum, etc.)
  • Function LORENTZ-PHI (lorentz-vector)
  • Function LORENTZ-THETA (lorentz-vector)

cl-ana.macro-utils

Basic macro utilities

CL-ANA.MACRO-UTILS

  • Macro DEFPLURAL (fname)
    Defines a function which maps the function with symbol fname across a list. The defined function has as its symbol fname with a trailing s character appended.
  • Macro MAP-BIND (fn symbols &body body)
    Binds each symbol in symbols to the value of (funcall fn symbol) and executes body inside of this lexical scope.
  • Macro ABBREV (short long)
    Defines abbreviated operator with name short expanding to a call to long.
  • Macro ABBREVS (&rest names)
    Defines multiple abbreviations simultaneously. Arguments are interpreted as: (abbrevs short1 long1 short2 long2 ...)
  • Macro DBIND (&rest args)
  • Macro MVBIND (&rest args)
  • Macro MVSETQ (&rest args)
  • Macro FVBIND (&rest args)
  • Macro POLL (test wait &body body)
    Repeatedly executes test form; if test returns true, executes body; otherwise waits for wait seconds and tries again. Returns last form in body.
  • Macro INRANGE (xlo op1 x op2 xhi &key (prec 0))
  • Macro CASE-EQUAL (form &body cases)
  • Macro COND-SETF (place value &optional (condition t))
    Only sets the place when the condition is met. condition may be one of three values: :place, :value, or :both. :place specifies that the place must evaluate to a non-nil value, :value specifies that the value must evaluate to a non-nil value, and :both specifies that both place and value must evaluate to non-nil values.
  • Macro PRINT-EVAL (arg)
  • Macro WITH-DEFAULT-ARGS (fn (&rest argbindings) &body body)
    Executes body with default argument values supplied to fn in a convenient way. fn is either the name of a function or a list (function local-name); fn is defined via flet and takes no arguments, but refers to the arguments in argbindings. argbindings are used analogously to let. Example: (with-default-args (list fn) ((x 3)) (fn)) yields (3). More useful examples would involve conditionally setting argument values in the body.
  • Macro WHEN-KEYWORDS (&body keyword-arg-specs)
    Creates a plist containing the keyword arguments only when the values are non-nil; if a keyword-arg-spec is a list, then the first element is taken to be the field symbol and the second element the expression to be passed as the value.
  • Macro DEFUN-WITH-SETF (fname (&rest lambda-list) &body body)
    Defines function along with setfable version when body is a single expression; throws error otherwise. This is limited to cases where the expression is already understandable to setf.
  • Function SYMB (&rest args)
  • Macro ALAMBDA (parms &body body)
  • Macro AIF (test then &optional else)
  • Macro AWHEN (test &body body)
  • Macro TIME-PROC (&body body)
    Times the execution of body and returns multiple values: 1. Real time in seconds, 2. Run time in seconds, and the rest being the return values of body.
  • Function LAMBDA-LIST-CALL-FORM (fname lambda-list)
    Returns the appropriate lambda-list call form for a function named fname and a lambda-list given by lambda-list. Macros are more difficult since lambda lists can have nested structure, so I'm only considering function lambda lists for now. This still works for macros which have this limited sort of lambda list however. One issue that is not currently resolved is supplying arguments which have a -supplied-p argument. Functions can be handled, but not in the same way as macros (since apply does not work). Also: &rest is handled only for functions becuause, again, there is no practical way to use this method for macros.
  • Macro SUPPRESS-OUTPUT (&body body)
    suppress-output redirects all output to /dev/null, thus silencing any messages printed to *standard-output*.
  • Macro KLAMBDA ((&rest key-args) &body body)
    Modified lambda which returns a keyword arg-accepting function with &allow-other-keys
  • Macro OLET ((&rest bindings) &body body)
    olet (at the moment) functions much like let*, except that each binding is only evaluated once at most, and not at all if the lexical binding is never used in the body. This can result in a tremendous speedup when used in creating context, e.g. looping over a table but only needing a few fields from the table. In test cases the compiler appeared to remove unused bindings entirely thanks to the symbol-macrolet.
  • Macro DLAMBDA (&rest ds)

cl-ana.makeres

No packages.

cl-ana.makeres-block

No packages.

cl-ana.makeres-branch

No packages.

cl-ana.makeres-graphviz

No packages.

cl-ana.makeres-macro

No packages.

cl-ana.makeres-progress

No packages.

cl-ana.makeres-table

No packages.

cl-ana.makeres-utils

No packages.

cl-ana.map

Defines generic functions for working with/converting things which behave like maps (in the mathematical sense), e.g. hash tables, alists, etc.

CL-ANA.MAP

  • Generic-Function MAP->ALIST (object)
    Returns the values of a data-source as an alist mapping the independent value to the dependent one. Multidimensional independent variable data can be represented as a list of values.
  • Method MAP->ALIST ((obj hash-table))
  • Method MAP->ALIST ((obj hash-table))
  • Method MAP->ALIST ((obj hash-table))
  • Function MAP->HASH-TABLE (object &optional test)

cl-ana.math-functions

No packages.

cl-ana.memoization

Provides memoized functions (only compute for new arguments, otherwise lookup in a hash table)

CL-ANA.MEMOIZATION

  • Function GET-MEMO-MAP (memo-fn)
    Returns the memoized function's value hash table.
  • Function RESET-MEMO-MAP (memo-fn)
    Resets the memoization hash table for memo-fn
  • Macro MEMOIZE (fn &key (test 'equal))
    Macro for memoizing any function; test argument allows you to specify how arguments will be looked up.
  • Macro MEMOLET (memo-fns &body body)
    A macro for defining mutually recursive memoized functions and executing body with knowledge of them. Cannot access the lookup tables via *memoized-map* in the body, since this would prevent garbage collection of the memoized function hash tables.
  • Function UNMEMOIZE (fn)
    Removes fn from the memoization lookup table; this prevents access to the lookup map from outside the function but allows the function to be garbage collected if necessary.
  • Macro DEFUN-MEMOIZED (function-name arg-list &body body)
    Macro for defining a memoized function. Note that currently there is a small inconvenience in that lambda-lists are not automatically added to the documentation used by things like SLIME.

cl-ana.ntuple-table

No packages.

cl-ana.package-utils

Provides various utilities for using packages as well as the abstraction of a package group

CL-ANA.PACKAGE-UTILS

  • Function SHADOWING-USE-PACKAGE (from-package &optional to-package)
    shadowing-imports all the exported symbols from gmath into the current package
  • Function ADD-PACKAGE-TO-GROUP (package group)
    Adds the package to the package group given by group.
  • Macro DEFPACKAGE-IN-GROUP (package-name group &body package-body)
    Defines a package while placing this package into the group specified by group. group can technically be any object, but I like to stick to keyword symbols. Any package statements can be used in the package-body portion.
  • Function USE-PACKAGE-GROUP (group &optional dest-package)
    Calls shadowing-use-package on each package in group and either the current package or dest-package.

cl-ana.pathname-utils

Utilities for working with pathnames

CL-ANA.PATHNAME-UTILS

  • Function PATHNAME-ABSOLUTE-P (pathname-or-string)
  • Function PATHNAME-RELATIVE-P (pathname-or-string)
  • Function ->ABSOLUTE-PATHNAME (pathname-or-string)
  • Function DIRECTORY-PATHNAME-P (pathname-or-string)
    Returns t iff pathname-or-string refers to a directory
  • Function MKDIRPATH (pathname-or-string)
    Returns a path which always refers to a directory (platform independent)
  • Function BASENAME (pathname)
    Returns basename of pathname; pathname-name strips the extension while this utility function preserves it.

cl-ana.plotting

No packages.

cl-ana.quantity

Provides basic physics functions such as dimensional analysis, units, and some common definitions.

CL-ANA.QUANTITY

  • Class QUANTITY
    SCALE   Accessor: QUANTITY-SCALE
    The numerical coefficient expressing the number of units the quantity represents.
    UNIT   Accessor: QUANTITY-UNIT
    The unit the quantity is measured via.
  • Function READER-MACRO-UNITS->QUANTITY (unit-list)
  • Generic-Function QUANTITY (obj)
    Forms a quantity from more basic types, such as symbols and numbers.
  • Method QUANTITY ((q quantity))
  • Method QUANTITY ((n number))
  • Method QUANTITY ((s symbol))
  • Method QUANTITY ((e err-num))
  • Macro DEFINE-UNIT (unit-symbol quantity)
    Defines a derived unit.
  • Function YOTTA (x)
  • Function ZETTA (x)
  • Function EXA (x)
  • Function PETA (x)
  • Function TERA (x)
  • Function GIGA (x)
  • Function MEGA (x)
  • Function KILO (x)
  • Function HECTO (x)
  • Function DECA (x)
  • Function DECI (x)
  • Function CENTI (x)
  • Function MILLI (x)
  • Function MICRO (x)
  • Function NANO (x)
  • Function PICO (x)
  • Function FEMTO (x)
  • Function ATTO (x)
  • Function ZEPTO (x)
  • Function YOCTO (x)
  • Function BINARY-KILO (x)
  • Function BINARY-MEGA (x)
  • Function BINARY-GIGA (x)
  • Function BINARY-TERA (x)
  • Method QUANTITY ((x1 (eql :hertz)))
  • Method QUANTITY ((x6 (eql :newton)))
  • Method QUANTITY ((x11 (eql :pascal)))
  • Method QUANTITY ((x16 (eql :joule)))
  • Method QUANTITY ((x21 (eql :watt)))
  • Method QUANTITY ((x26 (eql :coulomb)))
  • Method QUANTITY ((x31 (eql :volt)))
  • Method QUANTITY ((x36 (eql :farad)))
  • Method QUANTITY ((x41 (eql :ohm)))
  • Method QUANTITY ((x46 (eql :siemens)))
  • Method QUANTITY ((x51 (eql :weber)))
  • Method QUANTITY ((x56 (eql :tesla)))
  • Method QUANTITY ((x61 (eql :henry)))
  • Method QUANTITY ((x66 (eql :lumen)))
  • Method QUANTITY ((x71 (eql :lux)))
  • Method QUANTITY ((x76 (eql :becquerel)))
  • Method QUANTITY ((x81 (eql :gray)))
  • Method QUANTITY ((x86 (eql :sievert)))
  • Method QUANTITY ((x91 (eql :katal)))
  • Method QUANTITY ((x0 (eql :gram)))
  • Method QUANTITY ((x5 (eql :minute)))
  • Method QUANTITY ((x10 (eql :hour)))
  • Method QUANTITY ((x15 (eql :day)))
  • Method QUANTITY ((x20 (eql :year)))
  • Method QUANTITY ((x25 (eql :hectare)))
  • Method QUANTITY ((x30 (eql :liter)))
  • Method QUANTITY ((x35 (eql :tonne)))
  • Method QUANTITY ((x40 (eql :atomic-mass-unit)))
  • Method QUANTITY ((x46 (eql :angstrom)))
  • Method QUANTITY ((x51 (eql :barn)))
  • Method QUANTITY ((x56 (eql :bar)))
  • Method QUANTITY ((x61 (eql :atmosphere)))
  • Method QUANTITY ((x66 (eql :mmhg)))
  • Method QUANTITY ((x71 (eql :torr)))
  • Method QUANTITY ((x76 (eql :kph)))
  • Method QUANTITY ((x81 (eql :rpm)))
  • Method QUANTITY ((x0 (eql :inch)))
  • Method QUANTITY ((x5 (eql :foot)))
  • Method QUANTITY ((x10 (eql :yard)))
  • Method QUANTITY ((x15 (eql :mile)))
  • Method QUANTITY ((x20 (eql :nautical-mile)))
  • Method QUANTITY ((x25 (eql :acre)))
  • Method QUANTITY ((x30 (eql :teaspoon)))
  • Method QUANTITY ((x35 (eql :tablespoon)))
  • Method QUANTITY ((x40 (eql :fluid-ounce)))
  • Method QUANTITY ((x45 (eql :cup)))
  • Method QUANTITY ((x50 (eql :pint)))
  • Method QUANTITY ((x55 (eql :quart)))
  • Method QUANTITY ((x60 (eql :gallon)))
  • Method QUANTITY ((x65 (eql :pound)))
  • Method QUANTITY ((x70 (eql :grain)))
  • Method QUANTITY ((x75 (eql :dram)))
  • Method QUANTITY ((x80 (eql :ounce)))
  • Method QUANTITY ((x85 (eql :ton)))
  • Method QUANTITY ((x90 (eql :long-ton)))
  • Method QUANTITY ((x95 (eql :mph)))
  • Method QUANTITY ((x100 (eql :coffee-cup)))
  • Variable +C+
    (cl-ana.generic-math:* 299792458 :meter (cl-ana.generic-math:expt :second -1))
    Speed of light in vacuum
  • Method QUANTITY ((x (eql :fahrenheit)))
  • Method QUANTITY ((x (eql :celsius)))
  • Method QUANTITY ((x (eql :rankine)))
  • Function CONVERT-TEMPERATURE (temp to-units)
    Converts the temperature quantity temp into the temperature units to-units. Note that the result is unitless.
  • Method QUANTITY ((x0 (eql :electron-volt)))
  • Method QUANTITY ((x5 (eql :dyne)))
  • Method QUANTITY ((x10 (eql :calorie)))
  • Method QUANTITY ((x15 (eql :cal)))
  • Method QUANTITY ((x20 (eql :pound-force)))
  • Method QUANTITY ((x25 (eql :horsepower)))
  • Method QUANTITY ((x30 (eql :light-year)))
  • Method QUANTITY ((x35 (eql :astronomical-unit)))
  • Method QUANTITY ((x40 (eql :parsec)))
  • Function CONVERT-UNITS (quantity new-units)
    Gets the scale of quantity if expressed in new-units. new-units can be either a product unit (usual unit, e.g. meter/second) or a list of product units which is interpreted as a sum of units. Using a list of units results in a list of unit-scales, one element per unit in the sum. The quantity value is the result of multiplying the unit-scales with the corresponding product units and them summing. Useful for expressing U.S. quantities like heights in feet and inches.

cl-ana.reusable-table

Table wrapper for reading which automatically re-loads table for reading after fully reading the contents (not guarranteed by the raw table types).

CL-ANA.REUSABLE-TABLE

  • Class REUSABLE-TABLE
    CREATION-FN   Accessor: REUSABLE-TABLE-CREATION-FN
    Function which creates the table being wrapped.
    CREATION-FN-FORM   Accessor: REUSABLE-TABLE-OPENER-FORM
    Lisp form which returns the table opener function when evaluated. A table opener An optional field which assists in serializing reusable tables.
    RAW-TABLE   Accessor: INTERNAL-TABLE
    The table which is being wrapped.
    NEEDS-RELOADING   Accessor: REUSABLE-TABLE-NEEDS-RELOADING
    Boolean which tells the wrapper when it needs to close and re-open the table.
  • Function MAKE-REUSABLE-TABLE (creation-fn &optional opener-form)
    Returns result of creation-fn if reusable-table, else returns reusable-table which will make use of creation-fn to generate new copies when needed.
  • Macro WRAP-FOR-REUSE (table-creation-form &optional opener-form)
    Creates a reusable (when table-creation-from does not return a reusable-table) table which places the table-creation-form into a closure which will be evaluated each time the table gets re-read from the beginning. If the creation form returns a reusable-table, simply returns the table.

cl-ana.serialization

No packages.

cl-ana.statistics

No packages.

cl-ana.string-utils

String utilities not already provided by Alexandria

CL-ANA.STRING-UTILS

  • Function LISPIFY (symbol-or-string)
    Converts symbol or string into a string and replaces all spaces and underscores with -, and convert to uppercase.
  • Function STRING-APPEND (&rest strings)
  • Function LINES (string)
    Splits a string into a list of the lines comprising the string.
  • Function UNLINES (lines &optional (trailing-newline-p t))
    Joins a list of lines into original string, with optional trailing newline.
  • Function WORDS (string)
    Returns the read words (symbols, numbers, etc.) contained in a string
  • Function MKSTR (&rest args)

cl-ana.symbol-utils

Basic utilities for working with symbols

CL-ANA.SYMBOL-UTILS

  • Function KEYWORDIFY (symbol-or-string)
    Returns the keyword version of a symbol or string.
  • Function KEYSYMB (args)
    Returns a keyword symbol formed by symbol versions of each element in args interspersed with hyphens (-).
  • Macro KEYSYMBQ (&rest args)
    Convenient macro for using keysymb; quotes the list of args and passes it to keysymb.

cl-ana.table

Table class; provides basic necessary interface for working with sets of data.

CL-ANA.TABLE

  • Class TABLE
    FIELD-NAMES   Accessor: TABLE-FIELD-NAMES
    List of field names.
    ACCESS-MODE   Accessor: TABLE-ACCESS-MODE
    :write for a writable table, :read for a readable table, and :both for a table which has no restriction on being written to or read from only. nil for a table which is not open.
  • Function TABLE-OPEN-P (table)
  • Function TABLE-FIELD-SYMBOLS (table)
  • Generic-Function TABLE-LOAD-NEXT-ROW (table)
    Loads the next row into the current row buffer. Returns nil if the next row does not exist/there is a read failure (which can be the same thing), non-nil otherwise.
  • Generic-Function TABLE-ACTIVATE-FIELDS (table field-names)
    Function for optimization based on which fields are to be read from the table; default method is to do nothing which works when these optimizations do nothing for a particular table type.
  • Method TABLE-ACTIVATE-FIELDS (table field-names)
  • Method TABLE-ACTIVATE-FIELDS (table field-names)
  • Method TABLE-ACTIVATE-FIELDS (table field-names)
  • Generic-Function TABLE-GET-FIELD (table field-symbol)
    Gets the field datum from the current row for field denoted by the field-symbol
  • Generic-Function TABLE-SET-FIELD (table field-symbol value)
    Sets the field value of the current output row
  • Generic-Function TABLE-COMMIT-ROW (table)
    Commits (writes) the current output row to the table
  • Macro TABLE-PUSH-FIELDS (table &body field-specs)
    Sets fields and commits row of table using field-specs. Each field-spec is either a symbol which represents both the field-symbol and the variable storing the field data.
  • Generic-Function TABLE-CLOSE (table)
    Close any open files, etc.
  • Method TABLE-CLOSE (table)
  • Method TABLE-CLOSE ((tab table))
  • Generic-Function TABLE-NROWS (table)
    When available, returns the number of rows stored in the table, otherwise returns nil.
  • Method TABLE-NROWS (table)
  • Method TABLE-NROWS (table)
  • Method TABLE-NROWS (table)
  • Function TABLE-REDUCE (table fields fn &key initial-value)
    table-reduce mimics reduce but with the modification that fn should take one more argument than the number of fields specified with the first argument used to store the state as fn is called across the table. table-reduce can be used as a functional/non-macro solution to looping over the table. fields is a list of field names/symbols. They will be passed in the order specified to fn. fn is function taking the computation state as the first argument and then each selected field as an argument in the order given in fields; can use the state argument to collect a list of values for example.
  • Macro DO-TABLE ((rowvar table) field-selections &body body)
    Macro for iterating over a table. rowvar is a symbol which will be bound to the row number inside the loop body. You can optionally use a list (rowtype rowvar) which will allow for the rowvar to have a type declared for it. table is the table which will be looped upon. To select specific fields from the table for reading, specify all the desired field names in field-selections; if field-selections is nil then all fields will be read. Note that it is still more efficient to specify all desired fields; for two field data this results in about a 16% running time difference. Also you must specify either none or all of the desired fields to work with during the loop body. Each field-selection is a list of 1. field names to access during the loop, by default the value will be bound to the lispified field name as a symbol, 2. A list containing a symbol as the first element and the field name as the second which will be bound to the symbol given as the first element of the list. The code body will be run for each row in the table. If fields are explicitly selected, then you can use declare statements at the beginning of the loop body; otherwise this is not supported.
  • Function OPEN-TABLE-CHAIN (creation-functions)
    Creates a chain of tables by running the appropriate creation-function when the previous table fails on table-load-next-row. Each creation function should be a function taking zero arguments and returning a table.
  • Function RESET-TABLE-CHAIN (table-chain)
    Resets the table counter in the chain so that it can be re-read.
  • Method TABLE-LOAD-NEXT-ROW ((table table-chain))
  • Method TABLE-GET-FIELD ((table table-chain) field-symbol)
  • Function OPEN-PLIST-TABLE (plists)
  • Method TABLE-LOAD-NEXT-ROW ((table plist-table))
  • Method TABLE-GET-FIELD ((table plist-table) field-symbol)
  • Method TABLE-CLOSE ((table plist-table))
  • Function CREATE-PLIST-TABLE (field-names)
  • Method TABLE-SET-FIELD ((tab plist-table) field-symbol value)
  • Method TABLE-COMMIT-ROW ((tab plist-table))
  • Method TABLE-NROWS ((tab plist-table))

cl-ana.table-utils

Utilities for working with tables

CL-ANA.TABLE-UTILS

  • Function TABLE->PLISTS (table &key field-names (reverse-p t))
    Returns a list of plists containing the field values you specify. Only do this for tables that will reasonably fit into memory. If no field-names are specified, then all fields will be present in the result. Note that the resulting plists will occur in the reverse order as they occur in the table for efficiency.
  • Function TABLE-ROW->PLIST (table field-names)
    Reads the current row from table and generates a plist containing the field values of each field-name in the row.
  • Function TABLE-COPY (from to &optional fields)
    Reads all entries from from and writes them to to. If fields are specified, only selected fields are used, otherwise all fields are copied.

cl-ana.table-viewing

No packages.

cl-ana.tensor

tensor provides utilities for treating nested sequences as multidimensional arrays; integration into the generic math framework yields MATLAB/GNU Octave-style functionality with arrays, lists, etc.

CL-ANA.TENSOR

  • Function SEQUENCEP (x)
  • Function MAKE-TENSOR (dimension-list &key (type 'vector) (initial-element 0.0d0))
    Creates a tensor with each dimension in dimension-list denoting the length of the sequence at that dimension with the type of the sequences given by the optional type argument.
  • Function FUNCTION->TENSOR (dimension-list fn &key (type 'vector))
  • Function TENSOR-REF (tensor &rest subscripts)
    References tensor via subscripts
  • Function TREF (tensor &rest subscripts)
    Abbreviation for tensor-ref; setfable.
  • Function TENSOR-FLAT-REF (tensor subscript)
    References tensor by single subscript; done in such a way to mimick the way multidimensional arrays are stored in memory by e.g. C. Assumes rectangular tensor.
  • Function TFREF (tensor subscript)
    Abbreviation for tensor-flat-ref; setfable.
  • Function (setf TENSOR-FLAT-REF) (value tensor subscript)
  • Function (setf TFREF) (value tensor subscript)
  • Function (setf TENSOR-REF) (value tensor &rest subscripts)
  • Function (setf TREF) (value tensor &rest subscripts)
  • Function TENSOR-RANK (tensor)
  • Function TENSOR-DIMENSIONS (tensor)
    Returns a list of the sizes of the tensor for each dimension.
  • Function TENSOR-MAP (fn &rest xs)
    Maps fn across xs for arbitrarily deep sequences. Treats non-sequences as sequences of arbitrary depth.
  • Function TENSOR-+ (&rest xs)
    Convenient nickname for mapping + over tensors.
  • Function TENSOR-- (&rest xs)
    Convenient nickname for mapping - over tensors.
  • Function TENSOR-* (&rest xs)
    Convenient nickname for mapping * over tensors.
  • Function TENSOR-/ (&rest xs)
    Convenient nickname for mapping / over tensors.
  • Function TENSOR-CONTRACT (tensor-index-pairs &key (type 'vector))
    Contracts each tensor along the dimension specified by the specified index, resulting in a tensor of recursively rectangular sequences of type type. Each tensor-index-pair is a cons with the car being the tensor to contract and the cdr being the index denoting the dimension to contract along for this tensor. It is just the mathematical notion of tensor contraction. Example: multiplying matrices: A . B ==> (tensor-contract (list (cons A 1) (cons B 0))) In words, contract tensors A and B along the second index of A and the first index of B.

cl-ana.typed-table

Table types which have typed columns. Provides automatic conversion between foreign and LISP objects.

CL-ANA.TYPED-TABLE

  • Class TYPED-TABLE  (TABLE)
    FIELD-SPECS   Accessor: TABLE-FIELD-SPECS
    list of typespecs, one per field
    ROW-CSTRUCT   Accessor: TYPED-TABLE-ROW-CSTRUCT
    CFFI cstruct type designator for the row object
    ROW-POINTER   Accessor: TYPED-TABLE-ROW-POINTER
    pointer to foreign object storing current row information.
    LISP->C-CONVERTER-MAP   Accessor: TYPED-TABLE-LISP->C-CONVERTER-MAP
    Hash table which maps the field symbols to the lisp->c converter function for corresponding field.
    C->LISP-CONVERTER-MAP   Accessor: TYPED-TABLE-C->LISP-CONVERTER-MAP
    Hash table which maps the field symbols to the c->lisp converter function for corresponding field.
  • Function TYPESPEC->FIELD-NAMES (compound-typespec)
    Returns field names from the compound type designation.
  • Function TYPESPEC->FIELD-SPECS (compound-typespec)
    Returns field typespecs from the compound type designation.
  • Function TYPED-TABLE->TYPESPEC (table)
    Creates a typespec from the table

cl-ana.typespec

typespec provides a mechanism for referring to foreign or LISP datatypes as well as utilities for conversion between the two.

CL-ANA.TYPESPEC

  • Function TYPESPEC->CFFI-TYPE (&rest xs3)
  • Function TYPESPEC-COMPOUND-P (typespec)
    Tests a typespec for being a compound typespec.
  • Function TYPESPEC-COMPOUND-FIELD-ALIST (typespec)
    Returns the alist mapping field name to typespec.
  • Function TYPESPEC-COMPOUND-FIELD-NAMES (typespec)
    Returns the field names for the compound type.
  • Function TYPESPEC-COMPOUND-FIELD-SPECS (typespec)
    Returns the typespecs for the fields in the compound type.
  • Function TYPESPEC-ARRAY-P (typespec)
    Tests a typespec for being an array typespec.
  • Function TYPESPEC-ARRAY-ELEMENT-TYPE (typespec)
    Returns the element type for the array type.
  • Function TYPESPEC-ARRAY-DIM-LIST (typespec)
    Returns the list of dimension sizes for the array type.
  • Function TYPESPEC-ARRAY-RANK (typespec)
    Returns the number of dimensions (rank) of the array type.
  • Function TYPESPEC-ARRAY-SIZE (typespec)
    Returns the total number of elements in the array type.
  • Function TYPESPEC-FLATTEN-ARRAYS (typespec)
    Flattens an array typespec if typespec is an array typespec, otherwise returns typespec unchanged. Note that this operation is recursive, in that if there are arrays in the typespec(s) of the component type(s), then they are flattened as well.
  • Function TYPESPEC-FOREIGN-ALLOC (typespec &optional (count 1))
    Allocates space for count foreign objects of type specified by typespec.
  • Function TYPESPEC->LISP-TO-C (typespec)
    Returns a function which takes 1. a lisp object, 2. a corresponding C pointer and sets the fields/values of the C object recursively. The pointer to the C-object is returned.
  • Function TYPESPEC->C-TO-LISP (typespec)
    Returns a function which takes a c-pointer argument and returns a lisp object containing the converted values.
  • Function CHAR-VECTOR->STRING (char-vector &optional length)
    Returns a string version of a vector of integers interpreted as the numerical codes for characters. If argument length is given, the result contains only the first length characters, or if length is longer than the char-vector, the char-vector interpreted into a string as if length were not given.