The xarray Reference Manual

Table of Contents

The xarray Reference Manual

This is the xarray Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Thu Mar 11 15:19:29 2021 GMT+0.

1 Introduction

Time-stamp: <2013-12-26 14:12:48 tony>

* Using this file

  This README file is intended to be read by humans as well as
  processed by Emacs org-mode for publishing, for literate-programming
  of examples, for bug-tracking and task/issue management, etc.

** TODO [#A] Write up basic setup for using this file from org-mode
   - State "TODO"       from ""           [2010-06-07 Mon 16:18]

   leveraging ORG-MODE tools for mixing in TODO's within docs -- need
   to include incantation for this to do the right thing for the
   agenda view!

   Right now there are issues with common-lisp support from within
   babel within org-mode. The configuration is not clear right out of
   the box and requires a bit of work to get working.

#+begin_src lisp
  ;; emacs-lisp snippet for linking in using this and the in-lined
  ;; commented TODOs of course, still must be written
#+end_src


** TODO [#B] Quick example of using this.

** Credits

   Original Idea and majority (all?) work:  Tamas K. Papp 
   Mucking, cleaning, simplifying, maintainance: AJ Rossini 

** Quick Start

*** ASDF only, OBSOLETE!

#+begin_src lisp
  (asdf:oos 'asdf:load-op :xarray)
  (asdf:oos 'asdf:compile-op :xarray :force T)
#+end_src

*** QUICKLISP

#+begin_src lisp
  (ql:quickload :xarray)
#+end_src

   If you are a neanderthal, and want to go back to the roots, you can
   simply pull from github or similar:

#+srcname: 
#+begin_src sh
  git clone http://github.com/blindglobe/xarray.git
#+end_src

* Overview

  This package implements a generalized interface for array-like
  objects.  An array-like object is any structure whose data (but not
  necessarily metadata) could be simply mappable to either a lisp
  array or a list-of-list structure.

  This could be interpreted in that this forms either a rectangular or
  ragged-array (differential lengths of EITHER rows OR columns).  

  The idea is that we should be able to index an object's data, but
  might not be able to access specialized metadata.  We provide a
  means of having views into convienently indexable rectangular
  substructures, which are view-by-reference, not copies, (TODO: need
  to create indexing tools for pulling various combinations out).  In
  addition, there is a tool for taking a copy of the array into a lisp
  array (TODO: generalize to other array structures).

  General design is that xref works out of the box on lisp arrays and
  list-of-list structures.  Additional matrix packages could depend on
  xarray and extend the generics (i.e. lisp-matrix) or have
  patching-packages (think ASDF-SYSTEM-CONNECTIONS) register.

  In a sense, we just rely on the default situation of CLOS -- it'll
  tell users which structures need xref-able methods, and the users
  will just have to tell us.  But that means that XARRAY is their
  dependency, not that an XARRAY can look forward and load them (which
  might be worthwhile when using XCREATE or the conversion routines.

* API

** interface.lisp

(defgeneric xelttype (object)
(defgeneric xdims (object)
(defgeneric xdim (object dim)
(defgeneric xrank (object)
(defgeneric xsize (object)
(defgeneric xref (object &rest subscripts)
(defgeneric (setf xref) (value object &rest subscripts)
(defgeneric xsetf (destination source &key map-function)
(defgeneric xsimilar (rank object)
(defgeneric xcreate (class dimensions &optional options)
(defgeneric as* (class object copy-p options)

** operations.lisp

operations.lisp:29:  `(defgeneric ,name (a b &key &allow-other-keys)
operations.lisp:69:(defgeneric x= (a b &optional eps)
operations.lisp:117:  `(defgeneric ,name (a)
operations.lisp:221:(defgeneric xdot (a b)

** view.lisp

(defgeneric permutation (object &rest permutation)
(defgeneric transpose (object)
(defgeneric xslice (object &rest index-specifications)
(defgeneric (setf xslice) (value object &rest index-specifications)
; (defgeneric row-major-projection (object &rest dimensions)
(defgeneric column-major-projection (object &rest dimensions)
(defgeneric flat (object)
(defgeneric ancestor-subscripts (object index)


** Core
*** XREF

   Access individual elements in an array.

#+begin_src lisp
  (xref object
        #| 1 2 3 or similar indexing sequence |# )
  (setf (xref object
              #| 1 2 3 or similar indexing sequence |# )
        value)
#+end_src

  to retrieve or set an element.  This would be easy to do with aref
  if aref was a generic function, but for various (sensible) reasons,
  it is not.  I (here, this is Tamas) describe a simple interface with
  a few generic functions.  Any objects that has these methods is
  called "xrefable".  For a given datastructure, we must implement the
  following tools.

  queries (sub)structure and returns views which can be accessed and
  set.  The reference  manages the indicies in the resulting
  view.

#+begin_src lisp
  (xref object )
#+end_src

*** XDIMS
   queries dimensions of structure.  There is an open question[fn:1]
   whether an XDIM function should exist.

#+begin_src common-lisp
  (xdims object)  ;; returns list of all indicies
  (xdim object )
  (nth 0 (xdims object))
  (nth 1 (xdims object))
#+end_src

*** XELTTYPE

#+begin_src lisp
   (xelttype object &optional )
#+end_src

   queries element and substructure types.  If  is given, it
   returns the substructure, if  is nil, it returns the whole
   structure.

*** XCOPY

#+begin_src lisp
   (xcopy object )
#+end_src

   queries (sub)structure and returns copies.  If one gets confused
   between a view and copy, dire consequences could entail, so we use
   separate generic functions for reference and copy, rather than a
   single "xaccess", which could result in:

#+begin_src common-lisp
   (defmacro xref  (&rest args) (xaccess :type 'reference @args))
   (defmacro xcopy (&rest args) (xaccess :type 'copy      @args))
#+end_src

*** XNEW

   creates a new structure.  One could consider using a undefined
   object in order to implement this with setf, i.e. 

#+begin_src common-lisp
   (setf (xref undef-object ) object-with-right-structure)
#+end_src
   and having it return undef-object with the right value.  But there
   are a few other possibilities.

** Extended
*** XRANK
*** XSIMILAR
*** XSIZE
    Return the number of elements in the array (product of dimensions,
    so a zero-dimensional array has size 1).  Should be the analog of
    ARRAY-TOTAL-SIZE

*** XCREATE
    Creates a new xref-able object with a particular backing store
    (ARRAY, or LISTOFLIST, or MATRIX-LIKE, or DATAFRAME-LIKE).

*** AS*
    libraries specialize, so write for data store.

    Users should leverage AS or COPY-AS

*** AS
    user function for as*

*** COPY-AS
    user function for as* which makes a deep copy

*** TAKE
    
** Utility
   these are currently related to arrays.
*** CVECTOR
    returns a simple array of the specified element type, which is
    vector-ish, filled by contents.

*** CARRAY
    returns a simple array of the specified element type, which is
    array-ish (dimensioned), filled by contents.

*** CVECTOR*
    Same as cvector, but element-type is derived using NUMERIC-TYPE-CLASSIFIER. 

*** CARRAY*
    Same as carray, but element-type is derived using NUMERIC-TYPE-CLASSIFIER. 

* Approach in general

  Both copies and views on an array should be XREF-able.  

  Array and vector construction for LISP ARRAYS (the default and base storage class) are shown as follows: 

#+BEGIN_SRC lisp
  (defparameter *b* (xarray:cvector* (list 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0)))
  ,*b* ;; this is an array of 1 item, a list of 8 floats
  
  (defparameter *c* (xarray:cvector* 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0))
  ,*c* ;; this is an array of 8 items, each a float
  
  (defparameter *a* (xarray:carray* (list 2 4)
                                    0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0))
  ,*a*
  
  
  
  (defparameter *d* (xarray:cvector 'double-float 0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0))
  ,*d* ;; this is an array of 1 item, a list of 8 floats
  
  (defparameter *e* (xarray:cvector 'fixnum 0 1 2 3 4 5 6 7))
  ,*e* ;; this is an array of 8 items, each a float
  
  (defparameter *f* (xarray:carray 'fixnum (list 2 4)
                                    0 1 2 3 4 5 6 7))
  ,*f*
  
  (defparameter *g* (xarray:carray 'double-float (list 2 4)
                                    0.0 1.0 2.0 3.0 4.0 5.0 6.0 7.0))
  *g*
#+END_SRC

  This can be sliced and dices in a number of ways, 

#+begin_src common-lisp
  (xarray:xslice *a* :all 2)  ; third column
  (xarray:xslice *a* 0 :all) ; first row
#+end_src

  selects the 3th column of an array.[fn:2] , and then the first row.
  This view is also xrefable, so you can use

#+begin_src common-lisp
  (setf (xarray:xref (xarray:xslice *a* :all 2) 1) 9.0)
#+end_src

  to set element 2 in the 3rd column, which has value 6, to the
  value 9.  Changes will be made in the original array

#+begin_src common-lisp
  *a*
#+end_src

  since this is a view.  But for functions that just expect an array,
  they can use the interface (xref, xdims, etc) and not care where it
  is coming from.

  I have also implemented permutations (generalized transpose), and
  row-major projections.  If you want to collect the elements of a
  view in an array ("deep copy"), use

#+begin_src common-lisp
  (copy-as *a*)
  (copy-as (xarray:xslice *a* :all 2))
#+end_src

  which delivers a CL array of the original and then sliced xrefable object.  

  There are convenience functions that for easy array/vector creation,
  inspired by R:

#+begin_src common-lisp
  (carray* '(2 3) 1 2 3 4d0 5 6)
  ;; => #2A((1.0d0 2.0d0 3.0d0) (4.0d0 5.0d0 6.0d0))
#+end_src

  guess the type so that all of the elements would fit in.  See also
  cvector and carray (manually specified type) and cvector*.

* Roadmap, tasks, bugs.
** TODO [#B] unit testing [0/5]
   - State "TODO"       from ""           [2010-06-07 Mon 15:33]
*** TODO [#B] XDIMS unittests
    - State "TODO"       from ""           [2010-06-07 Mon 15:29]
*** TODO [#B] XTYPE unittests
    - State "TODO"       from ""           [2010-06-07 Mon 15:29]
*** TODO [#B] XREF unittests
    - State "TODO"       from ""           [2010-06-07 Mon 15:29]
*** TODO [#B] XCOPY unittests
    - State "TODO"       from ""           [2010-06-07 Mon 15:29]
*** TODO [#B] XNEW unittests
    - State "TODO"       from ""           [2010-06-07 Mon 15:29]
** TODO [#A] integrate linear algebra routines
   - State "TODO"       from ""           [2010-06-07 Mon 15:33]
   probably from GSLL?  It should
   be easy to rig an xrefable interface to GSLL arrays.
** TODO [#B] Specialized arrays [0/2]
   - State "TODO"       from ""           [2010-06-07 Mon 15:33]
   upper- and lower-triangular matrices, etc.  xrefable elements can
   be read-only, xref-writeable-p is an interface to test if an
   element is writeable, it was included specifically for this.
   In addition, integrate sparse matrices from cl-sparsematrix.
*** TODO [#B] Triangular matrices
    - State "TODO"       from ""           [2010-06-07 Mon 15:33]
*** TODO [#B] Sparse matrices
    - State "TODO"       from ""           [2010-06-07 Mon 15:33]
** TODO [#B] specialized subclasses for certain cases and operations
   - State "TODO"       from ""           [2010-06-07 Mon 15:34]
   eg views on matrices, a transpose-view would be much simpler (and
   faster, maybe?) than the generalized permute.  Some operations (such as
   outer products, multiplication, addition) could be highly optimized
   when we know more about the specific structure (e.g. triangular,
   only ones/zeros, etc...).
** TODO [#B] decent printing for xrefable objects,
   - State "TODO"       from ""           [2010-06-07 Mon 15:34]
   currently converted to array.
** TODO [#B] direct access from other systems
   - State "TODO"       from ""           [2010-06-07 Mon 15:34]
   certain views can be directly accommodated by LAPACK/GSLL (eg a
   matrix with a stride).  Minor possibility for speedup/memory
   savings.  This is related to optimization based on substructure. 
** TODO [#B] fix SLICE api between LISP-MATRIX and XARRAY
   - State "TODO"       from ""           [2010-06-07 Mon 15:38]
** TODO [#B] implement equalp for XREF-able objects
   - State "TODO"       from ""           [2010-06-07 Mon 15:40]
* Development in progress
  To use this from within org-mode/org-babel, C-c ' will put into
  slime / lisp editing mode
#+begin_src common-lisp
  (in-package :cl-user)
  (asdf:oos 'asdf:compile-op 'xarray :force t)
  (asdf:oos 'asdf:load-op 'xarray)
  (asdf:oos 'asdf:load-op 'xarray-test)
#+end_src
  Tamas was thinking about this being a general interface, but then in
  my (Tony's) opinion, included some specialized issues that needed to
  be considered here but handled elsewhere.  My limited understanding
  had to do with practical considerations; I don't need to be
  practical, and he does.  THIS is precisely where I am deviating in
  my further development of this.

  What I (Tony) am currently thinking about is to pay a penalty
  initially (and maybe for a while!) on speed of access and write a
  general interface using a range of possible back-ends.  So that we
  can get the interface clean: xref pulls out a value and puts it int
  an array of the same structure, xref* pulls out a value and sticks
  it into a lisp array or scalar and returns it.  Speed can be handled
  later by doing a compile-time/run-time tradeoff, we will pay the
  compile-time penalty, in exchange for run-time advantages.  This
  fits into the theme of rapid prototyping (slow exec) followed by
  rapid execution (post-proto...).

  We'll optimize for version 2.  Ha-ha.

  Current thinking on the above, is to stick them into separate
  packages.  In particular, I've factored out the listoflist
  infrastructure into its own package.

  Checking current test state; but this is currently broken!
#+begin_src common-lisp
  (in-package :xarray-ut)
  (run-tests :suite 'xarray-ut)
  ;; => #
  (describe (run-tests :suite 'xarray-ut))
#+end_src

** Development work and examples
   Here are any current trials that are undergoing development.
#+begin_src
(in-package :xarray-user)
;; and dev code goes here.
#+end_src

* Discussion

* Footnotes

[fn:1] this is aesthetic.  Why write a simple list extract tool when
it could suffice to use existing list extraction functions?  This also
leads to better programmer knowledge, as well as a single point of
optimization for the overall system (the internal system list
manipulation functions)

[fn:2] The slice interface is similar to Tamas' affi package, but now
arbitrary index vectors are allowed, much like R.

2 Systems

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

2.1 xarray

Author

Tamas K Papp

License

MIT

Description

Dependencies

• cl-utilities
• iterate
• metabang-bind
• anaphora

Source

xarray.asd (file)

Components

• package-init (module)
• basics (module)
• functionality (module)

3 Modules

Modules are listed depth-first from the system components tree.

3.1 xarray/package-init

Parent

xarray (system)

Location

src/

Component

package.lisp (file)

3.2 xarray/basics

Dependency

package-init (module)

Parent

xarray (system)

Location

src/

Components

• types.lisp (file)
• utilities.lisp (file)
• conditions.lisp (file)
• interface.lisp (file)

3.3 xarray/functionality

Dependency

basics (module)

Parent

xarray (system)

Location

src/

Components

• array.lisp (file)
• view.lisp (file)
• operations.lisp (file)
• sequences.lisp (file)
• atoms.lisp (file)

4 Files

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

4.1 Lisp

4.1.1 xarray.asd

Location

xarray.asd

Systems

xarray (system)

Packages

xarray-asd

4.1.2 xarray/package-init/package.lisp

Parent

package-init (module)

Location

src/package.lisp

Packages

xarray

4.1.3 xarray/basics/types.lisp

Parent

basics (module)

Location

src/types.lisp

Internal Definitions

fixnum-vector (type)

4.1.4 xarray/basics/utilities.lisp

Dependency

types.lisp (file)

Parent

basics (module)

Location

src/utilities.lisp

Exported Definitions

• cm-index (function)
• cm-subscripts (function)
• rm-index (function)
• rm-subscripts (function)

Internal Definitions

• delete-duplicate-keywords (function)
• element-conversion-function (function)
• fill-array-with-list (function)
• flat->pairs (function)
• invert-permutation (function)
• make-symbol* (function)
• maxf (macro)
• merge-options (function)
• minf (macro)
• mklist (function)
• multf (macro)
• numeric-type-classifier (function)
• pairs->flat (function)
• permute-sequence (function)
• valid-integer-subset-p (function)
• valid-permutation-p (function)
• vector-within-dimension-p (function)
• within-dimension-p (function)

4.1.5 xarray/basics/conditions.lisp

Dependency

utilities.lisp (file)

Parent

basics (module)

Location

src/conditions.lisp

Exported Definitions

• xdim-invalid-axis-number (condition)
• xref-incompatible-type (condition)
• xref-setting-readonly (condition)
• xref-subscript-out-of-bounds (condition)
• xref-wrong-number-of-subscripts (condition)

Internal Definitions

• dimensions (method)
• rank (method)
• subscripts (method)
• subscripts (method)
• subscripts (method)
• subscripts (method)

4.1.6 xarray/basics/interface.lisp

Dependency

conditions.lisp (file)

Parent

basics (module)

Location

src/interface.lisp

Exported Definitions

• as* (generic function)
• as* (method)
• as* (method)
• as* (method)
• copy-as (function)
• xcreate (generic function)
• xcreate (method)
• xcreate-similar (function)
• xdim (generic function)
• xdim (method)
• xdims (generic function)
• xdims (method)
• xelttype (generic function)
• xelttype (method)
• xrank (generic function)
• xrank (method)
• xref (generic function)
• xref (method)
• (setf xref) (generic function)
• xsetf (generic function)
• xsetf (method)
• xsimilar (generic function)
• xsimilar (method)
• xsimilar (method)
• xsize (generic function)
• xsize (method)

Internal Definitions

xarray-like (class)

4.1.7 xarray/functionality/array.lisp

Parent

functionality (module)

Location

src/array.lisp

Exported Definitions

• as* (method)
• as* (method)
• carray (function)
• carray* (function)
• cvector (function)
• cvector* (function)
• xcreate (method)
• xdim (method)
• xdims (method)
• xelttype (method)
• xrank (method)
• xref (method)
• (setf xref) (method)
• xsimilar (method)
• xsize (method)

4.1.8 xarray/functionality/view.lisp

Dependency

array.lisp (file)

Parent

functionality (module)

Location

src/view.lisp

Exported Definitions

• column-major-projection (generic function)
• column-major-projection (method)
• drop (function)
• flat (generic function)
• flat (method)
• flat-xview (class)
• original-ancestor (function)
• permutation (generic function)
• permutation (method)
• permutation-xview (class)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xelttype (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xref (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xsimilar (method)
• xsize (method)
• xsize (method)
• xsize (method)
• xslice (generic function)
• xslice (method)
• (setf xslice) (generic function)
• xslice-xview (class)
• xview (class)

Internal Definitions

• ancestor (method)
• ancestor-dimensions (method)
• ancestor-dimensions (method)
• ancestor-dimensions (method)
• ancestor-subscripts (generic function)
• ancestor-subscripts (method)
• column-major-projection-flat-xview (class)
• column-major-projection-xview (class)
• convert-slice-subscripts (function)
• dimensions (method)
• dimensions (method)
• dimensions (method)
• index-specification-dimension (function)
• index-specifications (method)
• parse-index-specification (function)
• transpose (generic function)
• transpose (method)

4.1.9 xarray/functionality/operations.lisp

Dependency

view.lisp (file)

Parent

functionality (module)

Location

src/operations.lisp

Exported Definitions

• x* (generic function)
• x* (method)
• x* (method)
• x* (method)
• x+ (generic function)
• x+ (method)
• x+ (method)
• x+ (method)
• x- (generic function)
• x- (method)
• x- (method)
• x- (method)
• x/ (generic function)
• x/ (method)
• x/ (method)
• x/ (method)
• x= (generic function)
• x= (method)
• xcollect (function)
• xconcat (function)
• xdot (generic function)
• xdot (method)
• xmap (function)
• xmax (generic function)
• xmax (method)
• xmax (method)
• xmean (function)
• xmin (generic function)
• xmin (method)
• xmin (method)
• xop (function)
• xorder (function)
• xprod (generic function)
• xprod (method)
• xprod (method)
• xsort (function)
• xsum (generic function)
• xsum (method)
• xsum (method)

Internal Definitions

• define-elementwise-operation (macro)
• define-flat-reduction (macro)
• xdims= (function)

4.1.10 xarray/functionality/sequences.lisp

Dependency

operations.lisp (file)

Parent

functionality (module)

Location

src/sequences.lisp

Exported Definitions

• int-seq (function)
• int-seq (class)
• xdims (method)
• xelttype (method)
• xref (method)
• xsize (method)
• (setf xsize) (method)

Internal Definitions

• seq (class)
• start (method)

4.1.11 xarray/functionality/atoms.lisp

Dependency

sequences.lisp (file)

Parent

functionality (module)

Location

src/atoms.lisp

Exported Definitions

• xdims (method)
• xelttype (method)
• xref (method)
• xsimilar (method)

5 Packages

Packages are listed by definition order.

5.1 xarray-asd

Source

xarray.asd

Use List

• asdf/interface
• common-lisp

5.2 xarray

Source

package.lisp (file)

Use List

• anaphora
• cl-utilities
• metabang.bind
• iterate
• common-lisp

Exported Definitions

• as* (generic function)
• as* (method)
• as* (method)
• as* (method)
• as* (method)
• as* (method)
• carray (function)
• carray* (function)
• cm-index (function)
• cm-subscripts (function)
• column-major-projection (generic function)
• column-major-projection (method)
• copy-as (function)
• cvector (function)
• cvector* (function)
• drop (function)
• flat (generic function)
• flat (method)
• flat-xview (class)
• int-seq (function)
• int-seq (class)
• original-ancestor (function)
• permutation (generic function)
• permutation (method)
• permutation-xview (class)
• rm-index (function)
• rm-subscripts (function)
• x* (generic function)
• x* (method)
• x* (method)
• x* (method)
• x+ (generic function)
• x+ (method)
• x+ (method)
• x+ (method)
• x- (generic function)
• x- (method)
• x- (method)
• x- (method)
• x/ (generic function)
• x/ (method)
• x/ (method)
• x/ (method)
• x= (generic function)
• x= (method)
• xcollect (function)
• xconcat (function)
• xcreate (generic function)
• xcreate (method)
• xcreate (method)
• xcreate-similar (function)
• xdim (generic function)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim (method)
• xdim-invalid-axis-number (condition)
• xdims (generic function)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdims (method)
• xdot (generic function)
• xdot (method)
• xelttype (generic function)
• xelttype (method)
• xelttype (method)
• xelttype (method)
• xelttype (method)
• xelttype (method)
• xmap (function)
• xmax (generic function)
• xmax (method)
• xmax (method)
• xmean (function)
• xmin (generic function)
• xmin (method)
• xmin (method)
• xop (function)
• xorder (function)
• xprod (generic function)
• xprod (method)
• xprod (method)
• xrank (generic function)
• xrank (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xrank (method)
• xref (generic function)
• xref (method)
• xref (method)
• xref (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (method)
• xref (method)
• (setf xref) (generic function)
• xref-incompatible-type (condition)
• xref-setting-readonly (condition)
• xref-subscript-out-of-bounds (condition)
• xref-wrong-number-of-subscripts (condition)
• xsetf (generic function)
• xsetf (method)
• xsimilar (generic function)
• xsimilar (method)
• xsimilar (method)
• xsimilar (method)
• xsimilar (method)
• xsimilar (method)
• xsize (generic function)
• xsize (method)
• xsize (method)
• xsize (method)
• xsize (method)
• xsize (method)
• xsize (method)
• (setf xsize) (generic function)
• (setf xsize) (method)
• xslice (generic function)
• xslice (method)
• (setf xslice) (generic function)
• xslice-xview (class)
• xsort (function)
• xsum (generic function)
• xsum (method)
• xsum (method)
• xview (class)

Internal Definitions

• ancestor (generic function)
• ancestor (method)
• ancestor-dimensions (generic function)
• ancestor-dimensions (method)
• ancestor-dimensions (method)
• ancestor-dimensions (method)
• ancestor-subscripts (generic function)
• ancestor-subscripts (method)
• column-major-projection-flat-xview (class)
• column-major-projection-xview (class)
• convert-slice-subscripts (function)
• define-elementwise-operation (macro)
• define-flat-reduction (macro)
• delete-duplicate-keywords (function)
• dimensions (generic function)
• dimensions (method)
• dimensions (method)
• dimensions (method)
• dimensions (method)
• element-conversion-function (function)
• fill-array-with-list (function)
• fixnum-vector (type)
• flat->pairs (function)
• index-specification-dimension (function)
• index-specifications (generic function)
• index-specifications (method)
• invert-permutation (function)
• make-symbol* (function)
• maxf (macro)
• merge-options (function)
• minf (macro)
• mklist (function)
• multf (macro)
• numeric-type-classifier (function)
• pairs->flat (function)
• parse-index-specification (function)
• permute-sequence (function)
• rank (generic function)
• rank (method)
• seq (class)
• start (generic function)
• start (method)
• subscripts (generic function)
• subscripts (method)
• subscripts (method)
• subscripts (method)
• subscripts (method)
• transpose (generic function)
• transpose (method)
• valid-integer-subset-p (function)
• valid-permutation-p (function)
• vector-within-dimension-p (function)
• within-dimension-p (function)
• xarray-like (class)
• xdims= (function)

6 Definitions

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

6.1 Exported definitions

6.1.1 Functions

Function: carray ELEMENT-TYPE DIMENSIONS &rest ELEMENTS

Return a (simple-array element-type dimensions) containing elements, coerced to element-type.

Package

xarray

Source

array.lisp (file)

Function: carray* DIMENSIONS &rest ELEMENTS

Return a (simple-array element-type dimensions) containing elements, coerced to element-type, where the elemen-type is obtained using numeric-type-classifier.

Package

xarray

Source

array.lisp (file)

Function: cm-index DIMENSIONS SUBSCRIPTS

Calculate the column-major flat index from subscripts (list of fixnums) and dimensions (list of fixnums). Works in the corner case when dimensions and subscripts are both nil.

Package

xarray

Source

utilities.lisp (file)

Function: cm-subscripts DIMENSIONS I

Return the column-major subscripts (list) for flat index
i (fixnum), using dimensions (list of fixnums). No error checking, for internal use only. Works in the corner case when dimension is nil.

Package

xarray

Source

utilities.lisp (file)

Function: copy-as CLASS OBJECT &rest OPTIONS

Convert OBJECT to CLASS as a deep copy, with the enforcement of no shared structure.

Package

xarray

Source

interface.lisp (file)

Function: cvector ELEMENT-TYPE &rest ELEMENTS

Return a (simple-array element-type (*)) containing elements, coerced to element-type.

Package

xarray

Source

array.lisp (file)

Function: cvector* &rest ELEMENTS

Return a (simple-array element-type (*)) containing elements, coerced to element-type, where the elemen-type is obtained using numeric-type-classifier.

Package

xarray

Source

array.lisp (file)

Function: drop OBJECT

Return a view with the unit dimensions dropped.

Package

xarray

Source

view.lisp (file)

Function: int-seq A &optional B

Create integer sequence 0,...,a-1 or, if b is given, a,...,b (with a<=b).

Package

xarray

Source

sequences.lisp (file)

Function: original-ancestor VIEW

Find the original ancestor (ie the one that is not a view). Simply returns objects which are not views. Since views can be nested, this needs to follow the chain backwards.

Package

xarray

Source

view.lisp (file)

Function: rm-index DIMENSIONS SUBSCRIPTS

Return a row-major flat index for given subscripts (coerced to a vector, list also accepted), using dimensions (also coerced to a vector, list also accepted). Checks for boundaries and rank.

Package

xarray

Source

utilities.lisp (file)

Function: rm-subscripts DIMENSIONS I

Return i decomposed to a list of subscripts, taking
dimensions (which is coerced to a vector) as a row-major indexing scheme. No error checking is performed, meant for internal use.

Package

xarray

Source

utilities.lisp (file)

Function: xcollect N FUNCTION &optional TARGET-SPEC

Collect the result of calling function n times into an array (type of target-spec, or determined using xsimilar). Indexing is (i ...), where i is from 0 to n-1. The rest of the indexes are determined from the first value.

Package

xarray

Source

operations.lisp (file)

Function: xconcat TARGET-TYPE &rest ARGUMENTS

Concatenate atoms and/or vectors into a vector.

Package

xarray

Source

operations.lisp (file)

Function: xcreate-similar TARGET-SPEC OBJECT DIMENSIONS &optional MORE-OPTIONS

If TARGET-SPEC is T or (CONS T OPTIONS), use xsimilar to determine target spec using object (and also merge options), otherwise use target-spec directly to create an object. This function is meant for internal use, when mapping functions need to determine a target spec from one of the arguments.

Package

xarray

Source

interface.lisp (file)

Function: xmap TARGET FUNCTION &rest ARGUMENTS

Apply function to arguments elementwise, and save the result in target.

Package

xarray

Source

operations.lisp (file)

Function: xmean A

Mean of the elements.

Package

xarray

Source

operations.lisp (file)

Function: xop RESULT-SPEC FUNCTION &rest VECTORS

Generalized outer product of vectors, using function.

Package

xarray

Source

operations.lisp (file)

Function: xorder VECTOR PREDICATE &key KEY STABLE-P

Return a vector of integers starting from 0, representing the permutation of elements in vector that would result if sorted according to predicate (which you can use in xslice, etc). Key is passed to sort. If stable-p, stable-sort is used.

Package

xarray

Source

operations.lisp (file)

Function: xsort VECTOR PREDICATE &key KEY STABLE-P

Sort vector using predicate. Calls xorder and returns order as the second value.

Package

xarray

Source

operations.lisp (file)

6.1.2 Generic functions

Generic Function: as* CLASS OBJECT COPY-P OPTIONS

Return an object converted to a given class, with
other properties (eg element types for arrays) as specified by the optional keyword arguments. The result may share structure with object, unless COPY-P. Similarly to XCREATE, class can be (cons class options). When class is nil, XSIMILAR is called to obtain the result type.

Usage note: libraries should specialize this method, but the user interface is AS or COPY-AS.

Package

xarray

Source

interface.lisp (file)

Methods

Method: as* (CLASS (eql vector)) OBJECT COPY-P OPTIONS

Source

array.lisp (file)

Method: as* (CLASS (eql array)) OBJECT COPY-P OPTIONS

Source

array.lisp (file)

Method: as* CLASS OBJECT COPY-P OPTIONS

Method: as* (CLASS (eql t)) OBJECT COPY-P OPTIONS

Method: as* (CLASS list) OBJECT COPY-P OPTIONS

Generic Function: column-major-projection OBJECT &rest DIMENSIONS

Row major projection to an xrefable object. Total
size needs to match the product of dimensions. If dimensions is omitted, it is taken to be the xsize of the object.

Package

xarray

Source

view.lisp (file)

Methods

Method: column-major-projection OBJECT &rest DIMENSIONS

Generic Function: flat OBJECT

Flat index for an object.
flat-xview

An xview where elements can be accessed by a "flat" index on [0,total size), but the actual mapping is implementation-dependent. Mainly used for elementwise access where the order of elements does not matter, especially elementwise reductions with commutative operations (eg sum, product, maximum, etc).

There are two special considerations for this xview: (1) it only has to implement reading elements, not setting them, (2) it has to implement ancestor-subscripts, which map the flat index to that of the ancestor.

NOTE: flat-xviews do NOT have to be compatible across classes! Eg for Lisp arrays a flat-xview could be row-major, while for some other object it could be column major, etc. Only use FLAT XVIEWs if you truly don’t care about the order.

Package

xarray

Source

view.lisp (file)

Methods

Method: flat OBJECT

Generic Function: permutation OBJECT &rest PERMUTATION

Takes an xarray-able object and creates a View which is a permutation of indexes.

Package

xarray

Source

view.lisp (file)

Methods

Method: permutation OBJECT &rest PERMUTATION

Generic Function: x* A B &key ELEMENT-TYPE &allow-other-keys

Elementwise
* of two arrays, or an array and a scalar.

Package

xarray

Source

operations.lisp (file)

Methods

Method: x* A B &key ELEMENT-TYPE

Method: x* A (B number) &key ELEMENT-TYPE

Method: x* (A number) B &key ELEMENT-TYPE

Generic Function: x+ A B &key ELEMENT-TYPE &allow-other-keys

Elementwise
+ of two arrays, or an array and a scalar.

Package

xarray

Source

operations.lisp (file)

Methods

Method: x+ A B &key ELEMENT-TYPE

Method: x+ A (B number) &key ELEMENT-TYPE

Method: x+ (A number) B &key ELEMENT-TYPE

Generic Function: x- A B &key ELEMENT-TYPE &allow-other-keys

Elementwise
- of two arrays, or an array and a scalar.

Package

xarray

Source

operations.lisp (file)

Methods

Method: x- A B &key ELEMENT-TYPE

Method: x- A (B number) &key ELEMENT-TYPE

Method: x- (A number) B &key ELEMENT-TYPE

Generic Function: x/ A B &key ELEMENT-TYPE &allow-other-keys

Elementwise
/ of two arrays, or an array and a scalar.

Package

xarray

Source

operations.lisp (file)

Methods

Method: x/ A B &key ELEMENT-TYPE

Method: x/ A (B number) &key ELEMENT-TYPE

Method: x/ (A number) B &key ELEMENT-TYPE

Generic Function: x= A B &optional EPS

Return non-nil if A and B have the same dimensions,, and the sup|A-B| <= eps.

Package

xarray

Source

operations.lisp (file)

Methods

Method: x= A B &optional EPS

Generic Function: xcreate CLASS DIMENSIONS &optional OPTIONS

Return a new object of given type and dimensions,
with additional options. Dimensions can be a list, or a single number. xcreate can also be called as
(XCREATE (CONS CLASS OPTIONS) DIMENSIONS), in which case it will split the cons, merge OPTIONS and call XCREATE again.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xcreate (CLASS (eql array)) DIMENSIONS &optional OPTIONS

Source

array.lisp (file)

Method: xcreate (CLASS list) DIMENSIONS &optional OPTIONS

Generic Function: xdim OBJECT DIM

Return the size of the dim-th dim. We use the
default unless there is some sensible reason to implement otherwise.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xdim (OBJECT flat-xview) AXIS-NUMBER

Source

view.lisp (file)

Method: xdim (OBJECT column-major-projection-flat-xview) AXIS-NUMBER

Source

view.lisp (file)

Method: xdim (OBJECT column-major-projection-xview) AXIS-NUMBER

Source

view.lisp (file)

Method: xdim (OBJECT xslice-xview) AXIS-NUMBER

Source

view.lisp (file)

Method: xdim (OBJECT permutation-xview) AXIS-NUMBER

Source

view.lisp (file)

Method: xdim (OBJECT array) AXIS-NUMBER

Source

array.lisp (file)

Method: xdim (OBJECT xarray-like) (DIM integer)

Generic Function: xdims OBJECT

Return a list of dimensions of object. The list
does not share structure with anything, so it can be freely modified.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xdims OBJECT

Source

atoms.lisp (file)

Method: xdims (SEQ seq)

Source

sequences.lisp (file)

Method: xdims (OBJECT flat-xview)

Source

view.lisp (file)

Method: xdims (OBJECT column-major-projection-flat-xview)

Source

view.lisp (file)

Method: xdims (OBJECT column-major-projection-xview)

Source

view.lisp (file)

Method: xdims (OBJECT xslice-xview)

Source

view.lisp (file)

Method: xdims (OBJECT permutation-xview)

Source

view.lisp (file)

Method: xdims (OBJECT array)

Source

array.lisp (file)

Method: xdims (OBJECT xarray-like)

Generic Function: xdot A B

Dot product of two vectors.

Package

xarray

Source

operations.lisp (file)

Methods

Method: xdot A B

Generic Function: xelttype OBJECT &key LIST-OF-ROWS LIST-OF-COLUMNS

Return the type of elements. If no restriction is
imposed, return T. By default, T is expected, numerically-oriented matrices being the exception and hence different.

If there is :list-of-rows or :list-of-columns specified, then return a list with the types for the rows or columns, respectively. These would be a repeated list of the same type in the case of a numerical single-typed matrix.

We do not throw an error for this not being specified - it is only specified FOR restrictions, not when there are no restrictions.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xelttype OBJECT &key LIST-OF-ROWS LIST-OF-COLUMNS

Source

atoms.lisp (file)

Method: xelttype (SEQ int-seq) &key LIST-OF-ROWS LIST-OF-COLUMNS

Source

sequences.lisp (file)

Method: xelttype (OBJECT xview) &key LIST-OF-ROWS LIST-OF-COLUMNS

Source

view.lisp (file)

Method: xelttype (OBJECT array) &key LIST-OF-ROWS LIST-OF-COLUMNS

Source

array.lisp (file)

Method: xelttype (OBJECT xarray-like) &key LIST-OF-ROWS LIST-OF-COLUMNS

Generic Function: xmax A

Maximum of the elements.

Package

xarray

Source

operations.lisp (file)

Methods

Method: xmax A

Method: xmax (A array)

Generic Function: xmin A

Minimum of the elements.

Package

xarray

Source

operations.lisp (file)

Methods

Method: xmin A

Method: xmin (A array)

Generic Function: xprod A

Product of the elements.

Package

xarray

Source

operations.lisp (file)

Methods

Method: xprod A

Method: xprod (A array)

Generic Function: xrank OBJECT

Returns the number of dimensions of object.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xrank (OBJECT flat-xview)

Source

view.lisp (file)

Method: xrank (OBJECT column-major-projection-flat-xview)

Source

view.lisp (file)

Method: xrank (OBJECT column-major-projection-xview)

Source

view.lisp (file)

Method: xrank (OBJECT xslice-xview)

Source

view.lisp (file)

Method: xrank (OBJECT permutation-xview)

Source

view.lisp (file)

Method: xrank (OBJECT array)

Source

array.lisp (file)

Method: xrank (OBJECT xarray-like)

Generic Function: xref OBJECT &rest SUBSCRIPTS

Generic Function: (setf xref) VALUE OBJECT &rest SUBSCRIPTS

Accesses the element of the object specified by subscripts.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xref OBJECT &rest SUBSCRIPTS

Source

atoms.lisp (file)

Method: xref (SEQ int-seq) &rest SUBSCRIPTS

Source

sequences.lisp (file)

Method: xref (OBJECT flat-xview) &rest SUBSCRIPTS

Source

view.lisp (file)

Method: xref (OBJECT column-major-projection-flat-xview) &rest SUBSCRIPTS

Method: (setf xref) VALUE (OBJECT column-major-projection-flat-xview) &rest SUBSCRIPTS

Source

view.lisp (file)

Method: xref (OBJECT column-major-projection-xview) &rest SUBSCRIPTS

Method: (setf xref) VALUE (OBJECT column-major-projection-xview) &rest SUBSCRIPTS

Source

view.lisp (file)

Method: xref (OBJECT xslice-xview) &rest SUBSCRIPTS

Method: (setf xref) VALUE (OBJECT xslice-xview) &rest SUBSCRIPTS

Source

view.lisp (file)

Method: xref (OBJECT permutation-xview) &rest SUBSCRIPTS

Method: (setf xref) VALUE (OBJECT permutation-xview) &rest SUBSCRIPTS

Source

view.lisp (file)

Method: xref (OBJECT array) &rest SUBSCRIPTS

Method: (setf xref) VALUE (OBJECT array) &rest SUBSCRIPTS

Source

array.lisp (file)

Method: xref (OBJECT xarray-like) &rest SUBSCRIPTS

Generic Function: xsetf DESTINATION SOURCE &key MAP-FUNCTION

Copy the elements of source to destination.
Map-function, if given, will be used to map the elements, the default is conversion (if necessary) with coerce.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xsetf DESTINATION SOURCE &key MAP-FUNCTION

Generic Function: xsimilar RANK OBJECT

Return (CONS CLASS OPTIONS) for creating a similar
object with new rank. If rank is T, use rank of object. NOTE: for methods, make sure you specialize rank to fixnum if you are not handling T.

This method needs to be clarified a bit – it is more about providing meta data for rebuilding, not about determining some notion of equalness.

Package

xarray

Source

interface.lisp (file)

Methods

Method: xsimilar RANK OBJECT

Source

atoms.lisp (file)

Method: xsimilar RANK (OBJECT xview)

Source

view.lisp (file)

Method: xsimilar RANK (OBJECT array)

Source

array.lisp (file)

Method: xsimilar (RANK (eql t)) OBJECT

Method: xsimilar RANK (OBJECT xarray-like)

Generic Function: xsize OBJECT

Return the total number of elements in object.

Package

xarray

Source

interface.lisp (file)

Writer

(setf xsize) (generic function)

Methods

Method: xsize (SEQ seq)

length of sequence

Source

sequences.lisp (file)

Method: xsize (FLAT-XVIEW flat-xview)

total size

Source

view.lisp (file)

Method: xsize (COLUMN-MAJOR-PROJECTION-FLAT-XVIEW column-major-projection-flat-xview)

total size

Source

view.lisp (file)

Method: xsize (OBJECT column-major-projection-xview)

Source

view.lisp (file)

Method: xsize (OBJECT array)

Source

array.lisp (file)

Method: xsize (OBJECT xarray-like)

Generic Function: (setf xsize) NEW-VALUE OBJECT

Package

xarray

Reader

xsize (generic function)

Methods

Method: (setf xsize) NEW-VALUE (SEQ seq)

length of sequence

Source

sequences.lisp (file)

Generic Function: xslice OBJECT &rest INDEX-SPECIFICATIONS

Slice of an object.

Package

xarray

Source

view.lisp (file)

Writer

(setf xslice) (generic function)

Methods

Method: xslice OBJECT &rest INDEX-SPECIFICATIONS

Implementation note: we cache dimensions.

Generic Function: (setf xslice) VALUE OBJECT &rest INDEX-SPECIFICATIONS

setting a slice of an object.

Package

xarray

Source

view.lisp (file)

Reader

xslice (generic function)

Generic Function: xsum A

Sum of the elements.

Package

xarray

Source

operations.lisp (file)

Methods

Method: xsum A

Method: xsum (A array)

6.1.3 Conditions

Condition: xdim-invalid-axis-number ()

Package

xarray

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Condition: xref-incompatible-type ()

Package

xarray

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods

subscripts (method)

Direct slots

Slot: subscripts

Initargs

:subscripts

Readers

subscripts (generic function)

Condition: xref-setting-readonly ()

Package

xarray

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods

subscripts (method)

Direct slots

Slot: subscripts

Initargs

:subscripts

Readers

subscripts (generic function)

Condition: xref-subscript-out-of-bounds ()

Package

xarray

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods

• dimensions (method)
• subscripts (method)

Direct slots

Slot: subscripts

Initargs

:subscripts

Readers

subscripts (generic function)

Slot: dimensions

Initargs

:dimensions

Readers

dimensions (generic function)

Condition: xref-wrong-number-of-subscripts ()

Package

xarray

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods

• rank (method)
• subscripts (method)

Direct slots

Slot: subscripts

Initargs

:subscripts

Readers

subscripts (generic function)

Slot: rank

Initargs

:rank

Readers

rank (generic function)

6.1.4 Classes

Class: flat-xview ()

Package

xarray

Source

view.lisp (file)

Direct superclasses

xview (class)

Direct methods

• ancestor-subscripts (method)
• xref (method)
• xdim (method)
• xdims (method)
• xrank (method)
• initialize-instance (method)
• ancestor-dimensions (method)
• xsize (method)

Direct slots

Slot: xsize

total size

Type

fixnum

Readers

xsize (generic function)

Slot: ancestor-dimensions

dimensions of ancestor

Type

list

Readers

ancestor-dimensions (generic function)

Class: int-seq ()

A sequence of integers.

Package

xarray

Source

sequences.lisp (file)

Direct superclasses

seq (class)

Direct methods

• print-object (method)
• xref (method)
• xelttype (method)
• start (method)

Direct slots

Slot: start

first integer

Type

integer

Initargs

:start

Initform

0

Readers

start (generic function)

Class: permutation-xview ()

Package

xarray

Source

view.lisp (file)

Direct superclasses

xview (class)

Direct methods

• xref (method)
• xref (method)
• xdim (method)
• xdims (method)
• xrank (method)
• initialize-instance (method)
• dimensions (method)

Direct slots

Slot: permutation

permutation

Type

xarray::fixnum-vector

Initargs

:permutation

Slot: dimensions

dimensions

Type

xarray::fixnum-vector

Initargs

:dimensions

Readers

dimensions (generic function)

Class: xslice-xview ()

Package

xarray

Source

view.lisp (file)

Direct superclasses

xview (class)

Direct methods

• xref (method)
• xref (method)
• xdim (method)
• xdims (method)
• xrank (method)
• dimensions (method)
• index-specifications (method)

Direct slots

Slot: index-specifications

vector of index specifications

Type

xarray::fixnum-vector

Initargs

:index-specifications

Readers

index-specifications (generic function)

Slot: dimensions

dimensions, cached

Type

xarray::fixnum-vector

Initargs

:dimensions

Readers

dimensions (generic function)

Class: xview ()

Package

xarray

Source

view.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

• permutation-xview (class)
• xslice-xview (class)
• column-major-projection-xview (class)
• column-major-projection-flat-xview (class)
• flat-xview (class)

Direct methods

• print-object (method)
• xsimilar (method)
• xelttype (method)
• ancestor (method)

Direct slots

Slot: ancestor

the view of an underlying object that is accessible with xref

Initargs

:ancestor

Readers

ancestor (generic function)

6.2 Internal definitions

6.2.1 Macros

Macro: define-elementwise-operation OPERATION &optional DOCUMENTATION NAME

Defines an elementwise operation, with some default methods that return arrays.

Package

xarray

Source

operations.lisp (file)

Macro: define-flat-reduction NAME MODIFY-MACRO DOCSTRING &body BODY

Define a generic function named NAME which reduces its argument elementwise. body is spliced into the iterate loop, and can be used for early returns, etc. See code for variable names.

Package

xarray

Source

operations.lisp (file)

Macro: maxf PLACE &rest VALUES

Replace with largest of the place and the given values.

Package

xarray

Source

utilities.lisp (file)

Macro: minf PLACE &rest VALUES

Replace with smallest of the place and the given values.

Package

xarray

Source

utilities.lisp (file)

Macro: multf PLACE &rest VALUES

Multiply (& set) the first argument by the rest.

Package

xarray

Source

utilities.lisp (file)

6.2.2 Functions

Function: convert-slice-subscripts INDEX-SPECIFICATIONS SUBSCRIPTS

Convert subscripts using index-specifications.

Package

xarray

Source

view.lisp (file)

Function: delete-duplicate-keywords PAIRS

Delete conses with duplicate keywords. Destructive.

Package

xarray

Source

utilities.lisp (file)

Function: element-conversion-function SOURCE DESTINATION

Return a conversion function that is identity if (subtypep source destination), or constructed with coerce otherwise.

Package

xarray

Source

utilities.lisp (file)

Function: fill-array-with-list ARRAY LIST

Fills array with elements from list, coerced to the appropriate type. No error checking, meant to be used internally. Return array.

Package

xarray

Source

utilities.lisp (file)

Function: flat->pairs LIST

Transform a flat list of keyword-option pairs to a list of conses.

Package

xarray

Source

utilities.lisp (file)

Function: index-specification-dimension INDEX-SPECIFICATION

Return dimension of parsed index-specification. Internal function, no error checking. Return nil for dropped dimensions.

Package

xarray

Source

view.lisp (file)

Function: invert-permutation PERMUTATION

Return the inverse of a valid permutation vector (validity is not checked, results are not defined for invalid permutations).

Package

xarray

Source

utilities.lisp (file)

Function: make-symbol* &rest ARGS

Build a symbol by concatenating each element of ARGS, and intern it in the current package. Elements can be strings or symbols.

Package

xarray

Source

utilities.lisp (file)

Function: merge-options &rest OPTIONS-SPECS

Merge options specifications. Duplicate pairs are removed, options that come later (both within and between arguments) are used.

Package

xarray

Source

utilities.lisp (file)

Function: mklist OBJ

Package

xarray

Source

utilities.lisp (file)

Function: numeric-type-classifier LIST

Numeric type classifier, finds the smallest subtype that can accomodate the elements of list, in the ordering fixnum < integer < float < complex < t. Rational, float (any kind) are classified as double-float, and complex numbers as (complex double-float). Meant to be used by simple array-constructing functions. Upgraded-array-element-type is called on end result.

Package

xarray

Source

utilities.lisp (file)

Function: pairs->flat PAIRS

Flatten a list of conses.

Package

xarray

Source

utilities.lisp (file)

Function: parse-index-specification INDEX-SPECIFICATION DIMENSION

Parse a index specification, returning either

- an integer i, with the dimension dropped,

- a pair (start . length), where start is the starting index, and
length is the number of valid indexes. If dimension is negative, indexing is decreasing from start. This is used for contiguous indexes

- a vector of indexes, for non-contiguous indexing.

All resulting indexes are valid, ie they are integers in
[0,dimension).

Range specifications:

Negative integers are interpreted as counted backwards from the right edge of the domain, ie i < 0 denotes element dimension-i. The l

Valid index-specification specifications (a and b are integers):

a index a, dimension dropped
(list a) index a, dimension not dropped
(list a b) range between a and b, inclusive. If b < a, reversed. :all all valid indexes, increasing order
:rev all valid indexes, decreasing order
(vector i1 ... in) vector of indexes, must be a set (no repetition).

Package

xarray

Source

view.lisp (file)

Function: permute-sequence PERMUTATION SEQUENCE

Return permuted sequence as a list. Works even if indexes repeat.

Package

xarray

Source

utilities.lisp (file)

Function: valid-integer-subset-p VECTOR DIMENSION

Return non-nil (t) iff vector is a valid subset (ie with no repetition) of integers 0,1,...,(1- dimension).

Package

xarray

Source

utilities.lisp (file)

Function: valid-permutation-p VECTOR &optional DIMENSION

Return non-nil (t) iff vector is a valid permutation of integers 0,1,...,(1- dimension).

Package

xarray

Source

utilities.lisp (file)

Function: vector-within-dimension-p VECTOR DIMENSION

Return non-nil iff all elements in vector are in [0,dimension).

Package

xarray

Source

utilities.lisp (file)

Function: within-dimension-p SUBSCRIPT DIMENSION

Check if 0 <= subscript < dimension.

Package

xarray

Source

utilities.lisp (file)

Function: xdims= A B

Return non-nil iff the dimensions of A and B are the same.

Package

xarray

Source

operations.lisp (file)

6.2.3 Generic functions

Generic Function: ancestor OBJECT

Package

xarray

Methods

Method: ancestor (XVIEW xview)

the view of an underlying object that is accessible with xref

Source

view.lisp (file)

Generic Function: ancestor-dimensions OBJECT

Package

xarray

Methods

Method: ancestor-dimensions (FLAT-XVIEW flat-xview)

dimensions of ancestor

Source

view.lisp (file)

Method: ancestor-dimensions (COLUMN-MAJOR-PROJECTION-FLAT-XVIEW column-major-projection-flat-xview)

dimensions of ancestor

Source

view.lisp (file)

Method: ancestor-dimensions (COLUMN-MAJOR-PROJECTION-XVIEW column-major-projection-xview)

dimensions of ancestor

Source

view.lisp (file)

Generic Function: ancestor-subscripts OBJECT INDEX

Map the flat index the subscripts of the ancestor.

Package

xarray

Source

view.lisp (file)

Methods

Method: ancestor-subscripts (OBJECT flat-xview) INDEX

Generic Function: dimensions CONDITION

Package

xarray

Methods

Method: dimensions (COLUMN-MAJOR-PROJECTION-XVIEW column-major-projection-xview)

dimensions

Source

view.lisp (file)

Method: dimensions (XSLICE-XVIEW xslice-xview)

dimensions, cached

Source

view.lisp (file)

Method: dimensions (PERMUTATION-XVIEW permutation-xview)

dimensions

Source

view.lisp (file)

Method: dimensions (CONDITION xref-subscript-out-of-bounds)

Source

conditions.lisp (file)

Generic Function: index-specifications OBJECT

Package

xarray

Methods

Method: index-specifications (XSLICE-XVIEW xslice-xview)

vector of index specifications

Source

view.lisp (file)

Generic Function: rank CONDITION

Package

xarray

Methods

Method: rank (CONDITION xref-wrong-number-of-subscripts)

Source

conditions.lisp (file)

Generic Function: start OBJECT

Package

xarray

Methods

Method: start (INT-SEQ int-seq)

first integer

Source

sequences.lisp (file)

Generic Function: subscripts CONDITION

Package

xarray

Methods

Method: subscripts (CONDITION xref-incompatible-type)

Source

conditions.lisp (file)

Method: subscripts (CONDITION xref-setting-readonly)

Source

conditions.lisp (file)

Method: subscripts (CONDITION xref-wrong-number-of-subscripts)

Source

conditions.lisp (file)

Method: subscripts (CONDITION xref-subscript-out-of-bounds)

Source

conditions.lisp (file)

Generic Function: transpose OBJECT

Tranposed view.

Package

xarray

Source

view.lisp (file)

Methods

Method: transpose OBJECT

6.2.4 Classes

Class: column-major-projection-flat-xview ()

Package

xarray

Source

view.lisp (file)

Direct superclasses

xview (class)

Direct methods

• xref (method)
• xref (method)
• xdim (method)
• xdims (method)
• xrank (method)
• ancestor-dimensions (method)
• xsize (method)

Direct slots

Slot: xsize

total size

Type

fixnum

Initargs

:xsize

Readers

xsize (generic function)

Slot: ancestor-dimensions

dimensions of ancestor

Type

list

Initargs

:ancestor-dimensions

Readers

ancestor-dimensions (generic function)

Class: column-major-projection-xview ()

Package

xarray

Source

view.lisp (file)

Direct superclasses

xview (class)

Direct methods

• xref (method)
• xref (method)
• xsize (method)
• xdim (method)
• xdims (method)
• xrank (method)
• ancestor-dimensions (method)
• dimensions (method)

Direct slots

Slot: dimensions

dimensions

Type

list

Initargs

:dimensions

Readers

dimensions (generic function)

Slot: ancestor-dimensions

dimensions of ancestor

Type

list

Initargs

:ancestor-dimensions

Readers

ancestor-dimensions (generic function)

Class: seq ()

Package

xarray

Source

sequences.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

int-seq (class)

Direct methods

• xdims (method)
• (setf xsize) (method)
• xsize (method)

Direct slots

Slot: xsize

length of sequence

Initargs

:xsize

Readers

xsize (generic function)

Writers

(setf xsize) (generic function)

Class: xarray-like ()

mixin virtual superclass to indicate support for
dispatch and generics. There should be no objects instantiated with this class.

Package

xarray

Source

interface.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• xsimilar (method)
• xref (method)
• xsize (method)
• xrank (method)
• xdim (method)
• xdims (method)
• xelttype (method)

6.2.5 Types

Type: fixnum-vector ()

Simple array of one dimension, containing fixnums.

Package

xarray

Source

types.lisp (file)

Appendix A Indexes

A.1 Concepts

A.2 Functions