The xarray Reference Manual

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

The xarray Reference Manual

This is the xarray Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Jun 15 06:10:30 2022 GMT+0.

Table of Contents


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.


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

2.1 xarray

Author

Tamas K Papp

License

MIT

Dependencies
  • cl-utilities (system).
  • iterate (system).
  • metabang-bind (system).
  • anaphora (system).
Source

xarray.asd.

Child Components

3 Modules

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


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

3.1 xarray/package-init

Source

xarray.asd.

Parent Component

xarray (system).

Child Component

package.lisp (file).


3.2 xarray/basics

Dependency

package-init (module).

Source

xarray.asd.

Parent Component

xarray (system).

Child Components

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

3.3 xarray/functionality

Dependency

basics (module).

Source

xarray.asd.

Parent Component

xarray (system).

Child Components

4 Files

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


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

4.1 Lisp


4.1.1 xarray/xarray.asd

Source

xarray.asd.

Parent Component

xarray (system).

ASDF Systems

xarray.

Packages

xarray-asd.


4.1.2 xarray/package-init/package.lisp

Source

xarray.asd.

Parent Component

package-init (module).

Packages

xarray.


4.1.3 xarray/basics/types.lisp

Source

xarray.asd.

Parent Component

basics (module).

Internals

fixnum-vector (type).


4.1.4 xarray/basics/utilities.lisp

Dependency

types.lisp (file).

Source

xarray.asd.

Parent Component

basics (module).

Public Interface
Internals

4.1.5 xarray/basics/conditions.lisp

Dependency

utilities.lisp (file).

Source

xarray.asd.

Parent Component

basics (module).

Public Interface
Internals

4.1.6 xarray/basics/interface.lisp

Dependency

conditions.lisp (file).

Source

xarray.asd.

Parent Component

basics (module).

Public Interface
Internals

xarray-like (class).


4.1.7 xarray/functionality/array.lisp

Source

xarray.asd.

Parent Component

functionality (module).

Public Interface

4.1.8 xarray/functionality/view.lisp

Dependency

array.lisp (file).

Source

xarray.asd.

Parent Component

functionality (module).

Public Interface
Internals

4.1.9 xarray/functionality/operations.lisp

Dependency

view.lisp (file).

Source

xarray.asd.

Parent Component

functionality (module).

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

4.1.10 xarray/functionality/sequences.lisp

Dependency

operations.lisp (file).

Source

xarray.asd.

Parent Component

functionality (module).

Public Interface
Internals

4.1.11 xarray/functionality/atoms.lisp

Dependency

sequences.lisp (file).

Source

xarray.asd.

Parent Component

functionality (module).

Public Interface

5 Packages

Packages are listed by definition order.


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

5.1 xarray

Source

package.lisp.

Use List
  • anaphora.
  • cl-utilities.
  • common-lisp.
  • iterate.
  • metabang.bind.
Public Interface
Internals

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

5.2 xarray-asd

Source

xarray.asd.

Use List
  • asdf/interface.
  • common-lisp.

6 Definitions

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


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

6.1 Public Interface


6.1.1 Ordinary 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.

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.

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.

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.

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.

Function: cvector (element-type &rest elements)

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

Package

xarray.

Source

array.lisp.

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.

Function: drop (object)

Return a view with the unit dimensions dropped.

Package

xarray.

Source

view.lisp.

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.

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.

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.

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.

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.

Function: xconcat (target-type &rest arguments)

Concatenate atoms and/or vectors into a vector.

Package

xarray.

Source

operations.lisp.

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.

Function: xmap (target function &rest arguments)

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

Package

xarray.

Source

operations.lisp.

Function: xmean (a)

Mean of the elements.

Package

xarray.

Source

operations.lisp.

Function: xop (result-spec function &rest vectors)

Generalized outer product of vectors, using function.

Package

xarray.

Source

operations.lisp.

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.

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.


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.

Methods
Method: as* ((class (eql vector)) object copy-p options)
Source

array.lisp.

Method: as* ((class (eql array)) object copy-p options)
Source

array.lisp.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Methods
Method: xcreate ((class (eql array)) dimensions &optional options)
Source

array.lisp.

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.

Methods
Method: xdim ((object flat-xview) axis-number)
Source

view.lisp.

Method: xdim ((object column-major-projection-flat-xview) axis-number)
Source

view.lisp.

Method: xdim ((object column-major-projection-xview) axis-number)
Source

view.lisp.

Method: xdim ((object xslice-xview) axis-number)
Source

view.lisp.

Method: xdim ((object permutation-xview) axis-number)
Source

view.lisp.

Method: xdim ((object array) axis-number)
Source

array.lisp.

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.

Methods
Method: xdims (object)
Source

atoms.lisp.

Method: xdims ((seq seq))
Source

sequences.lisp.

Method: xdims ((object flat-xview))
Source

view.lisp.

Method: xdims ((object column-major-projection-flat-xview))
Source

view.lisp.

Method: xdims ((object column-major-projection-xview))
Source

view.lisp.

Method: xdims ((object xslice-xview))
Source

view.lisp.

Method: xdims ((object permutation-xview))
Source

view.lisp.

Method: xdims ((object array))
Source

array.lisp.

Method: xdims ((object xarray-like))
Generic Function: xdot (a b)

Dot product of two vectors.

Package

xarray.

Source

operations.lisp.

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.

Methods
Method: xelttype (object &key list-of-rows list-of-columns)
Source

atoms.lisp.

Method: xelttype ((seq int-seq) &key list-of-rows list-of-columns)
Source

sequences.lisp.

Method: xelttype ((object xview) &key list-of-rows list-of-columns)
Source

view.lisp.

Method: xelttype ((object array) &key list-of-rows list-of-columns)
Source

array.lisp.

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.

Methods
Method: xmax (a)
Method: xmax ((a array))
Generic Function: xmin (a)

Minimum of the elements.

Package

xarray.

Source

operations.lisp.

Methods
Method: xmin (a)
Method: xmin ((a array))
Generic Function: xprod (a)

Product of the elements.

Package

xarray.

Source

operations.lisp.

Methods
Method: xprod (a)
Method: xprod ((a array))
Generic Function: xrank (object)

Returns the number of dimensions of object.

Package

xarray.

Source

interface.lisp.

Methods
Method: xrank ((object flat-xview))
Source

view.lisp.

Method: xrank ((object column-major-projection-flat-xview))
Source

view.lisp.

Method: xrank ((object column-major-projection-xview))
Source

view.lisp.

Method: xrank ((object xslice-xview))
Source

view.lisp.

Method: xrank ((object permutation-xview))
Source

view.lisp.

Method: xrank ((object array))
Source

array.lisp.

Method: xrank ((object xarray-like))
Generic Function: xref (object &rest subscripts)

Accesses the element of the object specified by subscripts.

Package

xarray.

Source

interface.lisp.

Methods
Method: xref (object &rest subscripts)
Source

atoms.lisp.

Method: xref ((seq int-seq) &rest subscripts)
Source

sequences.lisp.

Method: xref ((object flat-xview) &rest subscripts)
Source

view.lisp.

Method: xref ((object column-major-projection-flat-xview) &rest subscripts)
Source

view.lisp.

Method: xref ((object column-major-projection-xview) &rest subscripts)
Source

view.lisp.

Method: xref ((object xslice-xview) &rest subscripts)
Source

view.lisp.

Method: xref ((object permutation-xview) &rest subscripts)
Source

view.lisp.

Method: xref ((object array) &rest subscripts)
Source

array.lisp.

Method: xref ((object xarray-like) &rest subscripts)
Generic Function: (setf xref) (object &rest subscripts)

Accesses the element of the object specified by subscripts.

Package

xarray.

Source

interface.lisp.

Methods
Method: (setf xref) ((object column-major-projection-flat-xview) &rest subscripts)
Source

view.lisp.

Method: (setf xref) ((object column-major-projection-xview) &rest subscripts)
Source

view.lisp.

Method: (setf xref) ((object xslice-xview) &rest subscripts)
Source

view.lisp.

Method: (setf xref) ((object permutation-xview) &rest subscripts)
Source

view.lisp.

Method: (setf xref) ((object array) &rest subscripts)
Source

array.lisp.

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.

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.

Methods
Method: xsimilar (rank object)
Source

atoms.lisp.

Method: xsimilar (rank (object xview))
Source

view.lisp.

Method: xsimilar (rank (object array))
Source

array.lisp.

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.

Methods
Reader Method: xsize ((seq seq))

length of sequence

Source

sequences.lisp.

Target Slot

xsize.

Reader Method: xsize ((flat-xview flat-xview))

total size

Source

view.lisp.

Target Slot

xsize.

Reader Method: xsize ((column-major-projection-flat-xview column-major-projection-flat-xview))

total size

Source

view.lisp.

Target Slot

xsize.

Method: xsize ((object column-major-projection-xview))
Source

view.lisp.

Method: xsize ((object array))
Source

array.lisp.

Method: xsize ((object xarray-like))
Generic Writer: (setf xsize) (object)
Package

xarray.

Methods
Writer Method: (setf xsize) ((seq seq))

length of sequence

Source

sequences.lisp.

Target Slot

xsize.

Generic Function: xslice (object &rest index-specifications)

Slice of an object.

Package

xarray.

Source

view.lisp.

Methods
Method: xslice (object &rest index-specifications)

Implementation note: we cache dimensions.

Generic Function: (setf xslice) (object &rest index-specifications)

setting a slice of an object.

Package

xarray.

Source

view.lisp.

Generic Function: xsum (a)

Sum of the elements.

Package

xarray.

Source

operations.lisp.

Methods
Method: xsum (a)
Method: xsum ((a array))

6.1.3 Standalone methods

Method: initialize-instance :after ((object permutation-xview) &key)
Source

view.lisp.

Method: initialize-instance :after ((object flat-xview) &key)
Source

view.lisp.

Method: print-object ((object xview) stream)
Source

view.lisp.

Method: print-object ((object int-seq) stream)
Source

sequences.lisp.


6.1.4 Conditions

Condition: xdim-invalid-axis-number
Package

xarray.

Source

conditions.lisp.

Direct superclasses

error.

Condition: xref-incompatible-type
Package

xarray.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods

subscripts.

Direct slots
Slot: subscripts
Initargs

:subscripts

Readers

subscripts.

Writers

This slot is read-only.

Condition: xref-setting-readonly
Package

xarray.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods

subscripts.

Direct slots
Slot: subscripts
Initargs

:subscripts

Readers

subscripts.

Writers

This slot is read-only.

Condition: xref-subscript-out-of-bounds
Package

xarray.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: subscripts
Initargs

:subscripts

Readers

subscripts.

Writers

This slot is read-only.

Slot: dimensions
Initargs

:dimensions

Readers

dimensions.

Writers

This slot is read-only.

Condition: xref-wrong-number-of-subscripts
Package

xarray.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: subscripts
Initargs

:subscripts

Readers

subscripts.

Writers

This slot is read-only.

Slot: rank
Initargs

:rank

Readers

rank.

Writers

This slot is read-only.


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

6.1.5 Classes

Class: flat-xview
Package

xarray.

Source

view.lisp.

Direct superclasses

xview.

Direct methods
Direct slots
Slot: xsize

total size

Type

fixnum

Readers

xsize.

Writers

This slot is read-only.

Slot: ancestor-dimensions

dimensions of ancestor

Type

list

Readers

ancestor-dimensions.

Writers

This slot is read-only.

Class: int-seq

A sequence of integers.

Package

xarray.

Source

sequences.lisp.

Direct superclasses

seq.

Direct methods
Direct slots
Slot: start

first integer

Type

integer

Initform

0

Initargs

:start

Readers

start.

Writers

This slot is read-only.

Class: permutation-xview
Package

xarray.

Source

view.lisp.

Direct superclasses

xview.

Direct methods
Direct slots
Slot: permutation

permutation

Type

xarray::fixnum-vector

Initargs

:permutation

Slot: dimensions

dimensions

Type

xarray::fixnum-vector

Initargs

:dimensions

Readers

dimensions.

Writers

This slot is read-only.

Class: xslice-xview
Package

xarray.

Source

view.lisp.

Direct superclasses

xview.

Direct methods
Direct slots
Slot: index-specifications

vector of index specifications

Type

xarray::fixnum-vector

Initargs

:index-specifications

Readers

index-specifications.

Writers

This slot is read-only.

Slot: dimensions

dimensions, cached

Type

xarray::fixnum-vector

Initargs

:dimensions

Readers

dimensions.

Writers

This slot is read-only.

Class: xview
Package

xarray.

Source

view.lisp.

Direct subclasses
Direct methods
Direct slots
Slot: ancestor

the view of an underlying object that is accessible with xref

Initargs

:ancestor

Readers

ancestor.

Writers

This slot is read-only.


6.2 Internals


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

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.

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.

Macro: maxf (place &rest values)

Replace with largest of the place and the given values.

Package

xarray.

Source

utilities.lisp.

Macro: minf (place &rest values)

Replace with smallest of the place and the given values.

Package

xarray.

Source

utilities.lisp.

Macro: multf (place &rest values)

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

Package

xarray.

Source

utilities.lisp.


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

6.2.2 Ordinary functions

Function: convert-slice-subscripts (index-specifications subscripts)

Convert subscripts using index-specifications.

Package

xarray.

Source

view.lisp.

Function: delete-duplicate-keywords (pairs)

Delete conses with duplicate keywords. Destructive.

Package

xarray.

Source

utilities.lisp.

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.

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.

Function: flat->pairs (list)

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

Package

xarray.

Source

utilities.lisp.

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.

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.

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.

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.

Function: mklist (obj)
Package

xarray.

Source

utilities.lisp.

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.

Function: pairs->flat (pairs)

Flatten a list of conses.

Package

xarray.

Source

utilities.lisp.

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.

Function: permute-sequence (permutation sequence)

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

Package

xarray.

Source

utilities.lisp.

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.

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.

Function: vector-within-dimension-p (vector dimension)

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

Package

xarray.

Source

utilities.lisp.

Function: within-dimension-p (subscript dimension)

Check if 0 <= subscript < dimension.

Package

xarray.

Source

utilities.lisp.

Function: xdims= (a b)

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

Package

xarray.

Source

operations.lisp.


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

6.2.3 Generic functions

Generic Reader: ancestor (object)
Package

xarray.

Methods
Reader Method: ancestor ((xview xview))

the view of an underlying object that is accessible with xref

Source

view.lisp.

Target Slot

ancestor.

Generic Reader: ancestor-dimensions (object)
Package

xarray.

Methods
Reader Method: ancestor-dimensions ((flat-xview flat-xview))

dimensions of ancestor

Source

view.lisp.

Target Slot

ancestor-dimensions.

Reader Method: ancestor-dimensions ((column-major-projection-flat-xview column-major-projection-flat-xview))

dimensions of ancestor

Source

view.lisp.

Target Slot

ancestor-dimensions.

Reader Method: ancestor-dimensions ((column-major-projection-xview column-major-projection-xview))

dimensions of ancestor

Source

view.lisp.

Target Slot

ancestor-dimensions.

Generic Function: ancestor-subscripts (object index)

Map the flat index the subscripts of the ancestor.

Package

xarray.

Source

view.lisp.

Methods
Method: ancestor-subscripts ((object flat-xview) index)
Generic Reader: dimensions (condition)
Package

xarray.

Methods
Reader Method: dimensions ((column-major-projection-xview column-major-projection-xview))

dimensions

Source

view.lisp.

Target Slot

dimensions.

Reader Method: dimensions ((xslice-xview xslice-xview))

dimensions, cached

Source

view.lisp.

Target Slot

dimensions.

Reader Method: dimensions ((permutation-xview permutation-xview))

dimensions

Source

view.lisp.

Target Slot

dimensions.

Reader Method: dimensions ((condition xref-subscript-out-of-bounds))
Source

conditions.lisp.

Target Slot

dimensions.

Generic Reader: index-specifications (object)
Package

xarray.

Methods
Reader Method: index-specifications ((xslice-xview xslice-xview))

vector of index specifications

Source

view.lisp.

Target Slot

index-specifications.

Generic Reader: rank (condition)
Package

xarray.

Methods
Reader Method: rank ((condition xref-wrong-number-of-subscripts))
Source

conditions.lisp.

Target Slot

rank.

Generic Reader: start (object)
Package

xarray.

Methods
Reader Method: start ((int-seq int-seq))

first integer

Source

sequences.lisp.

Target Slot

start.

Generic Reader: subscripts (condition)
Package

xarray.

Methods
Reader Method: subscripts ((condition xref-incompatible-type))
Source

conditions.lisp.

Target Slot

subscripts.

Reader Method: subscripts ((condition xref-setting-readonly))
Source

conditions.lisp.

Target Slot

subscripts.

Reader Method: subscripts ((condition xref-wrong-number-of-subscripts))
Source

conditions.lisp.

Target Slot

subscripts.

Reader Method: subscripts ((condition xref-subscript-out-of-bounds))
Source

conditions.lisp.

Target Slot

subscripts.

Generic Function: transpose (object)

Tranposed view.

Package

xarray.

Source

view.lisp.

Methods
Method: transpose (object)

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

6.2.4 Classes

Class: column-major-projection-flat-xview
Package

xarray.

Source

view.lisp.

Direct superclasses

xview.

Direct methods
Direct slots
Slot: xsize

total size

Type

fixnum

Initargs

:xsize

Readers

xsize.

Writers

This slot is read-only.

Slot: ancestor-dimensions

dimensions of ancestor

Type

list

Initargs

:ancestor-dimensions

Readers

ancestor-dimensions.

Writers

This slot is read-only.

Class: column-major-projection-xview
Package

xarray.

Source

view.lisp.

Direct superclasses

xview.

Direct methods
Direct slots
Slot: dimensions

dimensions

Type

list

Initargs

:dimensions

Readers

dimensions.

Writers

This slot is read-only.

Slot: ancestor-dimensions

dimensions of ancestor

Type

list

Initargs

:ancestor-dimensions

Readers

ancestor-dimensions.

Writers

This slot is read-only.

Class: seq
Package

xarray.

Source

sequences.lisp.

Direct subclasses

int-seq.

Direct methods
Direct slots
Slot: xsize

length of sequence

Initargs

:xsize

Readers

xsize.

Writers

(setf xsize).

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.

Direct methods

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

6.2.5 Types

Type: fixnum-vector ()

Simple array of one dimension, containing fixnums.

Package

xarray.

Source

types.lisp.


Appendix A Indexes


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

A.1 Concepts


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

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   I   M   N   O   P   R   S   T   V   W   X  
Index Entry  Section

(
(setf xref): Public generic functions
(setf xref): Public generic functions
(setf xref): Public generic functions
(setf xref): Public generic functions
(setf xref): Public generic functions
(setf xref): Public generic functions
(setf xsize): Public generic functions
(setf xsize): Public generic functions
(setf xslice): Public generic functions

A
ancestor: Private generic functions
ancestor: Private generic functions
ancestor-dimensions: Private generic functions
ancestor-dimensions: Private generic functions
ancestor-dimensions: Private generic functions
ancestor-dimensions: Private generic functions
ancestor-subscripts: Private generic functions
ancestor-subscripts: Private generic functions
as*: Public generic functions
as*: Public generic functions
as*: Public generic functions
as*: Public generic functions
as*: Public generic functions
as*: Public generic functions

C
carray: Public ordinary functions
carray*: Public ordinary functions
cm-index: Public ordinary functions
cm-subscripts: Public ordinary functions
column-major-projection: Public generic functions
column-major-projection: Public generic functions
convert-slice-subscripts: Private ordinary functions
copy-as: Public ordinary functions
cvector: Public ordinary functions
cvector*: Public ordinary functions

D
define-elementwise-operation: Private macros
define-flat-reduction: Private macros
delete-duplicate-keywords: Private ordinary functions
dimensions: Private generic functions
dimensions: Private generic functions
dimensions: Private generic functions
dimensions: Private generic functions
dimensions: Private generic functions
drop: Public ordinary functions

E
element-conversion-function: Private ordinary functions

F
fill-array-with-list: Private ordinary functions
flat: Public generic functions
flat: Public generic functions
flat->pairs: Private ordinary functions
Function, carray: Public ordinary functions
Function, carray*: Public ordinary functions
Function, cm-index: Public ordinary functions
Function, cm-subscripts: Public ordinary functions
Function, convert-slice-subscripts: Private ordinary functions
Function, copy-as: Public ordinary functions
Function, cvector: Public ordinary functions
Function, cvector*: Public ordinary functions
Function, delete-duplicate-keywords: Private ordinary functions
Function, drop: Public ordinary functions
Function, element-conversion-function: Private ordinary functions
Function, fill-array-with-list: Private ordinary functions
Function, flat->pairs: Private ordinary functions
Function, index-specification-dimension: Private ordinary functions
Function, int-seq: Public ordinary functions
Function, invert-permutation: Private ordinary functions
Function, make-symbol*: Private ordinary functions
Function, merge-options: Private ordinary functions
Function, mklist: Private ordinary functions
Function, numeric-type-classifier: Private ordinary functions
Function, original-ancestor: Public ordinary functions
Function, pairs->flat: Private ordinary functions
Function, parse-index-specification: Private ordinary functions
Function, permute-sequence: Private ordinary functions
Function, rm-index: Public ordinary functions
Function, rm-subscripts: Public ordinary functions
Function, valid-integer-subset-p: Private ordinary functions
Function, valid-permutation-p: Private ordinary functions
Function, vector-within-dimension-p: Private ordinary functions
Function, within-dimension-p: Private ordinary functions
Function, xcollect: Public ordinary functions
Function, xconcat: Public ordinary functions
Function, xcreate-similar: Public ordinary functions
Function, xdims=: Private ordinary functions
Function, xmap: Public ordinary functions
Function, xmean: Public ordinary functions
Function, xop: Public ordinary functions
Function, xorder: Public ordinary functions
Function, xsort: Public ordinary functions

G
Generic Function, (setf xref): Public generic functions
Generic Function, (setf xsize): Public generic functions
Generic Function, (setf xslice): Public generic functions
Generic Function, ancestor: Private generic functions
Generic Function, ancestor-dimensions: Private generic functions
Generic Function, ancestor-subscripts: Private generic functions
Generic Function, as*: Public generic functions
Generic Function, column-major-projection: Public generic functions
Generic Function, dimensions: Private generic functions
Generic Function, flat: Public generic functions
Generic Function, index-specifications: Private generic functions
Generic Function, permutation: Public generic functions
Generic Function, rank: Private generic functions
Generic Function, start: Private generic functions
Generic Function, subscripts: Private generic functions
Generic Function, transpose: Private generic functions
Generic Function, x*: Public generic functions
Generic Function, x+: Public generic functions
Generic Function, x-: Public generic functions
Generic Function, x/: Public generic functions
Generic Function, x=: Public generic functions
Generic Function, xcreate: Public generic functions
Generic Function, xdim: Public generic functions
Generic Function, xdims: Public generic functions
Generic Function, xdot: Public generic functions
Generic Function, xelttype: Public generic functions
Generic Function, xmax: Public generic functions
Generic Function, xmin: Public generic functions
Generic Function, xprod: Public generic functions
Generic Function, xrank: Public generic functions
Generic Function, xref: Public generic functions
Generic Function, xsetf: Public generic functions
Generic Function, xsimilar: Public generic functions
Generic Function, xsize: Public generic functions
Generic Function, xslice: Public generic functions
Generic Function, xsum: Public generic functions

I
index-specification-dimension: Private ordinary functions
index-specifications: Private generic functions
index-specifications: Private generic functions
initialize-instance: Public standalone methods
initialize-instance: Public standalone methods
int-seq: Public ordinary functions
invert-permutation: Private ordinary functions

M
Macro, define-elementwise-operation: Private macros
Macro, define-flat-reduction: Private macros
Macro, maxf: Private macros
Macro, minf: Private macros
Macro, multf: Private macros
make-symbol*: Private ordinary functions
maxf: Private macros
merge-options: Private ordinary functions
Method, (setf xref): Public generic functions
Method, (setf xref): Public generic functions
Method, (setf xref): Public generic functions
Method, (setf xref): Public generic functions
Method, (setf xref): Public generic functions
Method, (setf xsize): Public generic functions
Method, ancestor: Private generic functions
Method, ancestor-dimensions: Private generic functions
Method, ancestor-dimensions: Private generic functions
Method, ancestor-dimensions: Private generic functions
Method, ancestor-subscripts: Private generic functions
Method, as*: Public generic functions
Method, as*: Public generic functions
Method, as*: Public generic functions
Method, as*: Public generic functions
Method, as*: Public generic functions
Method, column-major-projection: Public generic functions
Method, dimensions: Private generic functions
Method, dimensions: Private generic functions
Method, dimensions: Private generic functions
Method, dimensions: Private generic functions
Method, flat: Public generic functions
Method, index-specifications: Private generic functions
Method, initialize-instance: Public standalone methods
Method, initialize-instance: Public standalone methods
Method, permutation: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
Method, rank: Private generic functions
Method, start: Private generic functions
Method, subscripts: Private generic functions
Method, subscripts: Private generic functions
Method, subscripts: Private generic functions
Method, subscripts: Private generic functions
Method, transpose: Private generic functions
Method, x*: Public generic functions
Method, x*: Public generic functions
Method, x*: Public generic functions
Method, x+: Public generic functions
Method, x+: Public generic functions
Method, x+: Public generic functions
Method, x-: Public generic functions
Method, x-: Public generic functions
Method, x-: Public generic functions
Method, x/: Public generic functions
Method, x/: Public generic functions
Method, x/: Public generic functions
Method, x=: Public generic functions
Method, xcreate: Public generic functions
Method, xcreate: Public generic functions
Method, xdim: Public generic functions
Method, xdim: Public generic functions
Method, xdim: Public generic functions
Method, xdim: Public generic functions
Method, xdim: Public generic functions
Method, xdim: Public generic functions
Method, xdim: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdims: Public generic functions
Method, xdot: Public generic functions
Method, xelttype: Public generic functions
Method, xelttype: Public generic functions
Method, xelttype: Public generic functions
Method, xelttype: Public generic functions
Method, xelttype: Public generic functions
Method, xmax: Public generic functions
Method, xmax: Public generic functions
Method, xmin: Public generic functions
Method, xmin: Public generic functions
Method, xprod: Public generic functions
Method, xprod: Public generic functions
Method, xrank: Public generic functions
Method, xrank: Public generic functions
Method, xrank: Public generic functions
Method, xrank: Public generic functions
Method, xrank: Public generic functions
Method, xrank: Public generic functions
Method, xrank: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xref: Public generic functions
Method, xsetf: Public generic functions
Method, xsimilar: Public generic functions
Method, xsimilar: Public generic functions
Method, xsimilar: Public generic functions
Method, xsimilar: Public generic functions
Method, xsimilar: Public generic functions
Method, xsize: Public generic functions
Method, xsize: Public generic functions
Method, xsize: Public generic functions
Method, xsize: Public generic functions
Method, xsize: Public generic functions
Method, xsize: Public generic functions
Method, xslice: Public generic functions
Method, xsum: Public generic functions
Method, xsum: Public generic functions
minf: Private macros
mklist: Private ordinary functions
multf: Private macros

N
numeric-type-classifier: Private ordinary functions

O
original-ancestor: Public ordinary functions

P
pairs->flat: Private ordinary functions
parse-index-specification: Private ordinary functions
permutation: Public generic functions
permutation: Public generic functions
permute-sequence: Private ordinary functions
print-object: Public standalone methods
print-object: Public standalone methods

R
rank: Private generic functions
rank: Private generic functions
rm-index: Public ordinary functions
rm-subscripts: Public ordinary functions

S
start: Private generic functions
start: Private generic functions
subscripts: Private generic functions
subscripts: Private generic functions
subscripts: Private generic functions
subscripts: Private generic functions
subscripts: Private generic functions

T
transpose: Private generic functions
transpose: Private generic functions

V
valid-integer-subset-p: Private ordinary functions
valid-permutation-p: Private ordinary functions
vector-within-dimension-p: Private ordinary functions

W
within-dimension-p: Private ordinary functions

X
x*: Public generic functions
x*: Public generic functions
x*: Public generic functions
x*: Public generic functions
x+: Public generic functions
x+: Public generic functions
x+: Public generic functions
x+: Public generic functions
x-: Public generic functions
x-: Public generic functions
x-: Public generic functions
x-: Public generic functions
x/: Public generic functions
x/: Public generic functions
x/: Public generic functions
x/: Public generic functions
x=: Public generic functions
x=: Public generic functions
xcollect: Public ordinary functions
xconcat: Public ordinary functions
xcreate: Public generic functions
xcreate: Public generic functions
xcreate: Public generic functions
xcreate-similar: Public ordinary functions
xdim: Public generic functions
xdim: Public generic functions
xdim: Public generic functions
xdim: Public generic functions
xdim: Public generic functions
xdim: Public generic functions
xdim: Public generic functions
xdim: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims: Public generic functions
xdims=: Private ordinary functions
xdot: Public generic functions
xdot: Public generic functions
xelttype: Public generic functions
xelttype: Public generic functions
xelttype: Public generic functions
xelttype: Public generic functions
xelttype: Public generic functions
xelttype: Public generic functions
xmap: Public ordinary functions
xmax: Public generic functions
xmax: Public generic functions
xmax: Public generic functions
xmean: Public ordinary functions
xmin: Public generic functions
xmin: Public generic functions
xmin: Public generic functions
xop: Public ordinary functions
xorder: Public ordinary functions
xprod: Public generic functions
xprod: Public generic functions
xprod: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xrank: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xref: Public generic functions
xsetf: Public generic functions
xsetf: Public generic functions
xsimilar: Public generic functions
xsimilar: Public generic functions
xsimilar: Public generic functions
xsimilar: Public generic functions
xsimilar: Public generic functions
xsimilar: Public generic functions
xsize: Public generic functions
xsize: Public generic functions
xsize: Public generic functions
xsize: Public generic functions
xsize: Public generic functions
xsize: Public generic functions
xsize: Public generic functions
xslice: Public generic functions
xslice: Public generic functions
xsort: Public ordinary functions
xsum: Public generic functions
xsum: Public generic functions
xsum: Public generic functions

Jump to:   (  
A   C   D   E   F   G   I   M   N   O   P   R   S   T   V   W   X  

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

A.4 Data types

Jump to:   A   B   C   F   I   M   O   P   S   T   U   V   X  
Index Entry  Section

A
array.lisp: The xarray/functionality/array․lisp file
atoms.lisp: The xarray/functionality/atoms․lisp file

B
basics: The xarray/basics module

C
Class, column-major-projection-flat-xview: Private classes
Class, column-major-projection-xview: Private classes
Class, flat-xview: Public classes
Class, int-seq: Public classes
Class, permutation-xview: Public classes
Class, seq: Private classes
Class, xarray-like: Private classes
Class, xslice-xview: Public classes
Class, xview: Public classes
column-major-projection-flat-xview: Private classes
column-major-projection-xview: Private classes
Condition, xdim-invalid-axis-number: Public conditions
Condition, xref-incompatible-type: Public conditions
Condition, xref-setting-readonly: Public conditions
Condition, xref-subscript-out-of-bounds: Public conditions
Condition, xref-wrong-number-of-subscripts: Public conditions
conditions.lisp: The xarray/basics/conditions․lisp file

F
File, array.lisp: The xarray/functionality/array․lisp file
File, atoms.lisp: The xarray/functionality/atoms․lisp file
File, conditions.lisp: The xarray/basics/conditions․lisp file
File, interface.lisp: The xarray/basics/interface․lisp file
File, operations.lisp: The xarray/functionality/operations․lisp file
File, package.lisp: The xarray/package-init/package․lisp file
File, sequences.lisp: The xarray/functionality/sequences․lisp file
File, types.lisp: The xarray/basics/types․lisp file
File, utilities.lisp: The xarray/basics/utilities․lisp file
File, view.lisp: The xarray/functionality/view․lisp file
File, xarray.asd: The xarray/xarray․asd file
fixnum-vector: Private types
flat-xview: Public classes
functionality: The xarray/functionality module

I
int-seq: Public classes
interface.lisp: The xarray/basics/interface․lisp file

M
Module, basics: The xarray/basics module
Module, functionality: The xarray/functionality module
Module, package-init: The xarray/package-init module

O
operations.lisp: The xarray/functionality/operations․lisp file

P
Package, xarray: The xarray package
Package, xarray-asd: The xarray-asd package
package-init: The xarray/package-init module
package.lisp: The xarray/package-init/package․lisp file
permutation-xview: Public classes

S
seq: Private classes
sequences.lisp: The xarray/functionality/sequences․lisp file
System, xarray: The xarray system

T
Type, fixnum-vector: Private types
types.lisp: The xarray/basics/types․lisp file

U
utilities.lisp: The xarray/basics/utilities․lisp file

V
view.lisp: The xarray/functionality/view․lisp file

X
xarray: The xarray system
xarray: The xarray package
xarray-asd: The xarray-asd package
xarray-like: Private classes
xarray.asd: The xarray/xarray․asd file
xdim-invalid-axis-number: Public conditions
xref-incompatible-type: Public conditions
xref-setting-readonly: Public conditions
xref-subscript-out-of-bounds: Public conditions
xref-wrong-number-of-subscripts: Public conditions
xslice-xview: Public classes
xview: Public classes

Jump to:   A   B   C   F   I   M   O   P   S   T   U   V   X