Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
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.
Next: Systems, Previous: The xarray Reference Manual, Up: The xarray Reference Manual [Contents][Index]
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. PappMucking, 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.
Next: Modules, Previous: Introduction, Up: The xarray Reference Manual [Contents][Index]
The main system appears first, followed by any subsystem dependency.
Tamas K Papp
MIT
Next: Files, Previous: Systems, Up: The xarray Reference Manual [Contents][Index]
Modules are listed depth-first from the system components tree.
Next: xarray/basics, Previous: Modules, Up: Modules [Contents][Index]
xarray (system).
package.lisp (file).
Next: xarray/functionality, Previous: xarray/package-init, Up: Modules [Contents][Index]
package-init (module).
xarray (system).
Previous: xarray/basics, Up: Modules [Contents][Index]
basics (module).
xarray (system).
Next: Packages, Previous: Modules, Up: The xarray Reference Manual [Contents][Index]
Files are sorted by type and then listed depth-first from the systems components trees.
Next: xarray/package-init/package.lisp, Previous: Lisp, Up: Lisp [Contents][Index]
xarray (system).
Next: xarray/basics/types.lisp, Previous: xarray/xarray.asd, Up: Lisp [Contents][Index]
package-init (module).
Next: xarray/basics/utilities.lisp, Previous: xarray/package-init/package.lisp, Up: Lisp [Contents][Index]
basics (module).
fixnum-vector (type).
Next: xarray/basics/conditions.lisp, Previous: xarray/basics/types.lisp, Up: Lisp [Contents][Index]
types.lisp (file).
basics (module).
Next: xarray/basics/interface.lisp, Previous: xarray/basics/utilities.lisp, Up: Lisp [Contents][Index]
utilities.lisp (file).
basics (module).
Next: xarray/functionality/array.lisp, Previous: xarray/basics/conditions.lisp, Up: Lisp [Contents][Index]
conditions.lisp (file).
basics (module).
xarray-like (class).
Next: xarray/functionality/view.lisp, Previous: xarray/basics/interface.lisp, Up: Lisp [Contents][Index]
functionality (module).
Next: xarray/functionality/operations.lisp, Previous: xarray/functionality/array.lisp, Up: Lisp [Contents][Index]
array.lisp (file).
functionality (module).
Next: xarray/functionality/sequences.lisp, Previous: xarray/functionality/view.lisp, Up: Lisp [Contents][Index]
view.lisp (file).
functionality (module).
Next: xarray/functionality/atoms.lisp, Previous: xarray/functionality/operations.lisp, Up: Lisp [Contents][Index]
operations.lisp (file).
functionality (module).
Previous: xarray/functionality/sequences.lisp, Up: Lisp [Contents][Index]
sequences.lisp (file).
functionality (module).
Next: Definitions, Previous: Files, Up: The xarray Reference Manual [Contents][Index]
Packages are listed by definition order.
Next: xarray-asd, Previous: Packages, Up: Packages [Contents][Index]
Next: Indexes, Previous: Packages, Up: The xarray Reference Manual [Contents][Index]
Definitions are sorted by export status, category, package, and then by lexicographic order.
Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]
Next: Generic functions, Previous: Public Interface, Up: Public Interface [Contents][Index]
Return a (simple-array element-type dimensions) containing elements, coerced to element-type.
Return a (simple-array element-type dimensions) containing elements, coerced to element-type, where the elemen-type is obtained using numeric-type-classifier.
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.
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.
Convert OBJECT to CLASS as a deep copy, with the enforcement of no shared structure.
Return a (simple-array element-type (*)) containing elements, coerced to element-type.
Return a (simple-array element-type (*)) containing elements, coerced to element-type, where the elemen-type is obtained using numeric-type-classifier.
Return a view with the unit dimensions dropped.
Create integer sequence 0,...,a-1 or, if b is given, a,...,b (with a<=b).
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.
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.
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.
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.
Concatenate atoms and/or vectors into a vector.
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.
Apply function to arguments elementwise, and save the result in target.
Mean of the elements.
Generalized outer product of vectors, using function.
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.
Sort vector using predicate. Calls xorder and returns order as the second value.
Next: Standalone methods, Previous: Ordinary functions, Up: Public Interface [Contents][Index]
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.
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.
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.
Takes an xarray-able object and creates a View which is a permutation of indexes.
Elementwise
* of two arrays, or an array and a scalar.
Elementwise
+ of two arrays, or an array and a scalar.
Elementwise
- of two arrays, or an array and a scalar.
Elementwise
/ of two arrays, or an array and a scalar.
Return non-nil if A and B have the same dimensions,, and the sup|A-B| <= eps.
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.
Return the size of the dim-th dim. We use the
default unless there is some sensible reason to implement
otherwise.
Return a list of dimensions of object. The list
does not share structure with anything, so it can be freely
modified.
Dot product of two vectors.
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.
Maximum of the elements.
Minimum of the elements.
Product of the elements.
Returns the number of dimensions of object.
Accesses the element of the object specified by subscripts.
Accesses the element of the object specified by subscripts.
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.
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.
Return the total number of elements in object.
total size
total size
Slice of an object.
setting a slice of an object.
Sum of the elements.
Next: Conditions, Previous: Generic functions, Up: Public Interface [Contents][Index]
Next: Classes, Previous: Standalone methods, Up: Public Interface [Contents][Index]
error.
error.
:subscripts
This slot is read-only.
error.
:subscripts
This slot is read-only.
error.
:subscripts
This slot is read-only.
Previous: Conditions, Up: Public Interface [Contents][Index]
dimensions of ancestor
list
This slot is read-only.
A sequence of integers.
seq.
vector of index specifications
xarray::fixnum-vector
:index-specifications
This slot is read-only.
dimensions, cached
xarray::fixnum-vector
:dimensions
This slot is read-only.
Previous: Public Interface, Up: Definitions [Contents][Index]
Next: Ordinary functions, Previous: Internals, Up: Internals [Contents][Index]
Defines an elementwise operation, with some default methods that return arrays.
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.
Replace with largest of the place and the given values.
Replace with smallest of the place and the given values.
Multiply (& set) the first argument by the rest.
Next: Generic functions, Previous: Macros, Up: Internals [Contents][Index]
Convert subscripts using index-specifications.
Delete conses with duplicate keywords. Destructive.
Return a conversion function that is identity if (subtypep source destination), or constructed with coerce otherwise.
Fills array with elements from list, coerced to the appropriate type. No error checking, meant to be used internally. Return array.
Transform a flat list of keyword-option pairs to a list of conses.
Return dimension of parsed index-specification. Internal function, no error checking. Return nil for dropped dimensions.
Return the inverse of a valid permutation vector (validity is not checked, results are not defined for invalid permutations).
Build a symbol by concatenating each element of ARGS, and intern it in the current package. Elements can be strings or symbols.
Merge options specifications. Duplicate pairs are removed, options that come later (both within and between arguments) are used.
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.
Flatten a list of conses.
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).
Return permuted sequence as a list. Works even if indexes repeat.
Return non-nil (t) iff vector is a valid subset (ie with no repetition) of integers 0,1,...,(1- dimension).
Return non-nil (t) iff vector is a valid permutation of integers 0,1,...,(1- dimension).
Return non-nil iff all elements in vector are in [0,dimension).
Check if 0 <= subscript < dimension.
Return non-nil iff the dimensions of A and B are the same.
Next: Classes, Previous: Ordinary functions, Up: Internals [Contents][Index]
dimensions of ancestor
dimensions of ancestor
dimensions of ancestor
Map the flat index the subscripts of the ancestor.
dimensions
dimensions, cached
dimensions
vector of index specifications
rank.
Tranposed view.
Next: Types, Previous: Generic functions, Up: Internals [Contents][Index]
dimensions of ancestor
list
:ancestor-dimensions
This slot is read-only.
length of sequence
:xsize
mixin virtual superclass to indicate support for
dispatch and generics. There should be no objects instantiated with
this class.
Previous: Definitions, Up: The xarray Reference Manual [Contents][Index]
Jump to: | (
A C D E F G I M N O P R S T V W X |
---|
Jump to: | (
A C D E F G I M N O P R S T V W X |
---|
Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]
Jump to: | A D I P R S X |
---|
Jump to: | A D I P R S X |
---|
Jump to: | A B C F I M O P S T U V X |
---|
Jump to: | A B C F I M O P S T U V X |
---|