Broadcasts two matrices into identical shapes, coercing to the type of the first matrix.
Intended to prepare for elementwise operations.
Returns a vector containing the two broadcasted matrices.
Throws an error if not possible.

Broadcasts two matrices into identical shapes. Intended to prepare for elementwise operations.
Returns a vector containing the two broadcasted matrices.
Throws an error if not possible.

Returns the common shape that can be broadcast to from all the shapes specified, 
or nil if such a shape does not exist.

Checks if an array can contain a specified Java type, if so returns the orifginal array, otherwise
returns a copy of the array that can support the specified type.

Protocol to support the mutable add-inner-product! operation. This is a common operation that may be 
optimised by the underlying implementation. Implementations should consider extra optimisations for
specific constant factors e.g. 0.0 and 1.0 but this is not mandatory.

Optional protocol for add-product operation.

Intended to support optimised implementations for result = m + a * b

Optional protocol for mutable add-product! operation.

Intended to support optimised implementations for m = m + a * b

Protocol for add-scaled operation. 

Implementations may assume that factor is a scalar.

Intended to support optimised implementations for result = m + a * factor

Protocol for mutable add-scaled! operation.

Implementations may assume that factor is a scalar.

Intended to support optimised implementations for m = m + a * factor

Protocol for add-product operation.

Intended to support optimised implementations for result = m + a * b * factor

Protocol for mutable add-product! operation.

Intended to support optimised implementations for m = m + a * b * factor

Option protocol for quick determination of array matrics

Protocol for assigning values element-wise to mutable arrays.

Protocol for construction of a block diagonal matrix.

Protocol to support broadcasting over one or more dimensions.

Protocol to broadcast into a given matrix shape and perform coercion in one step.

Equivalent to (coerce m (broadcast-like m a)) but likely to be more efficient.

Protocol to broadcast into a given matrix shape. May also perform coercion if needed by the implementation.

Procotol for Cholesky decomposition

Protocol to coerce a parameter to a format used by a specific implementation. It is
up to the implementation to determine what parameter types they support.
If the implementation is unable to perform coercion, it must return nil.

Implementations are encouraged to avoid taking a full copy of the data, for performance reasons.
It is preferable to use structural sharing with the original data if possible.

If coercion is impossible (e.g. param has an invalid shape or element types) then the
implementation *may* throw an exception, though it may also return nil to get default behaviour,
which should implement any expected exceptions.

If an implementation implements coercion via copying, then it is recommended that conversion
should be to the most efficient packed representation (i.e. as defined by 'pack')

Implementations must also be able to coerce valid scalar values (presumably via the identity function)

Protocol for column setting. Should set a dimension 1 (column) slice to the given column value.

Protocol to allow element-wise comparison of elements in an array or matrix.

Protocol to compute a matrix by calling a function on each indexed location. The function f will be called
as (f x y z ...) for all index values.

Protocol to allow conversion to Clojure-friendly vector format. Optional for implementers,
however providing an efficient implementation is strongly encouraged to enable fast interop
with Clojure vectors.

Protocol for general dataset functionality

Protocol for constructing a dense array from the given data.

EXPERIMENTAL: Protocol for querying multi-dimensioned datasets

Protocol to return standard dimension information about an array.
dimensionality and dimension-count are mandatory for implementations

Protocol for arrays supporting labelled dimensions

Protocol for getting element data as a flattened double array

Procotol for Eigenvalue decomposition

Protocol to return the total count of elements in matrix. Result may be any integer type,
typically a java.lang.Long

Protocol to return the minimum and maximum elements in a numerical array. Must throw an exception
if the array is not numerical.

Coerces a data structure to nested persistent vectors

Protocol to support the 'pow' function. Should raise every element of a matrix to a
given exponent. Default implementation uses Java's Math/pow function which is appropriate for
double values: arrays supporting arbitrary precision numbers or complex types will need to
provide their own implementation.

Protocol to allow functional-style operations on matrix elements.

Protocol for returning the generic numerical functions of a matrix implementation

Protocol for returning the generic/default values of a matrix implementation

Protocol for assigning values element-wise to an array, broadcasting as needed.

Protocol for creating an immutable copy of a matrix. If implemented, must return a fully immutable
copy of the given matrix.

The default implementation will attempt to choose a suitable immutable matrix implementation.

Protocol for general implementation functionality. Required to support implementation metadata and
matrix construction.

Protocol for indexed read access to arrays, matrices and vectors. Indexing values can
be assumed to be integers. indexes may be any sequence or Java array of index values.

Protocol for indexed 'setter' operations. These are like Clojure's 'assoc'
function, i.e. they return an updated copy of the original array, which is itself unchanged.
Should be supported for any immutable array type.

Protocol for indexed mutable setter access to matrices and vectors.
Must be supported for any mutable matrix type.

Protocol for determining if an object is a valid index. Implementations may implement this protocol to support their own index types.

Protocol for getting elements of an array at the specified indices.

Protocol for setting elements of an array at the specified indices

Protocol for computing least-square solution to a linear matrix equation

Protocol to support element-wise logistic function on a numerical array.

Protocol to support mutable element-wise logistic function on a numerical array.

Protocol for LU decomposition

Protocol for map-indexed operation on matrices

Protocol to support mathematical functions applied element-wise to a numerical array.

Protocol to support mutable mathematical functions applied element-wise to a numerical array.

Protocol to support addition and subtraction on arbitrary matrices.
These are elementwise operations that should support broadcasting.

Protocol to support mutable addition and subtraction

Protocol for cloning a matrix value. The new clone must be mutable if the original
matrix is mutable, i.e. mutating the clone must not affect the original. The copy should be shallow, if applicable.

Protocol for accessing columns of a matrix

Protocol to support element-wise division operator.

One-arg version returns the reciprocal of all elements.

Protocol to support mutable element-wise division operater.

One-arg version computes the reciprocal of all elements.

Protocol for numerical array equality operations.

Protocol for numerical array equality operations with a specified tolerance. Arrays are defined as equal 
if the array shapes are the same and and for all corresponding elements ai and bi we have: |ai-bi|<=eps

Should be equivalent to PMatrixEquality when eps is zero.

Protocol to support matrix multiplication on numerical arrays.

Implementation may return nil if the implementation does not support one of the parameters, in
which case a more general operation will be attempted.

Protocol to support mutable matrix multiplication on an arbitrary matrix, vector or scalar

Protocol to support mutable array scaling by scalar values.

Protocol to support common 2D numerical matrix operations

Protocol for matrix predicates like identity-matrix? or zero-matrix?

Protocol for general inner and outer products of numerical arrays.
Products should use + and * as normally defined for numerical types

Protocol to support computing the rank (number of linearly independent rows) in a matrix

Protocol for accessing rows of a matrix

Protocol to support numerical array scaling by scalar values. Provided because array classes may have
efficient specialised scaling operaions.

Works according the the default definition of multiplication for the matrix class
(usually numerical, i.e. equivalent to clojure.core/+)

Protocol to support getting slices of an array.  If implemented, must return either a view, a scalar
or an immutable sub-matrix: it must *not* return copied data. i.e. making a full copy must be avoided.

Protocol for picking out subsections of a 2D matrix. Should return a mutable view if possible.
The default implementation creates a new vector containing the diagonal values.

Protocol for coercing to a mutable format. May return the original array, if it is already fully mutable, 
otherwise should return a fully mutable copy of the array.

May return nil to indicate that a default implementation should be used.

The default implementation will attempt to choose a suitable mutable matrix implementation.

Protocol for creating a mutable copy of a matrix. If implemented, must return either a fully mutable
copy of the given matrix, or nil if not possible.

The default implementation will attempt to choose a suitable mutable matrix implementation.

Protocol for mutable versions of common vector operations

Protocol for creating and handling native arrays. Implementations must return a native format array if they
are able to, or nil otherwise.

Protocol for constructing sparse arrays. Should return nil if the sparse array shape is not supported.

Protocol for getting non-zero indices of an array

Protocol for matrix and vector norms

Protocol for identifying numerical arrays. Should return true if every element in the
array is guaranteed to be a valid numerical value.

Protocol for getting element data as a flattened object array

Protocol for matrix reorder. 

By default, re-orders along the first (major) dimension, but may reorder along any dimension by 
specifiying the dimension argument.

Indicies can be any seqable object containing the indices along the specified dimension to select.
An index can be selected multiple times (which created repreated slices), or not at all (which excludes
the slice from the result).

Some implementation may implement re-ordering using lightweight or mutable views over the original array 
data.

Protocol to efficiently pack an array, according to the most efficient representation for a given
implementation.

Definition of pack is up to the implementation to interpret, but the general rules are:
1. Must not change the value of the array for comparison purposes
2. Must not change the shape of the array
3. May preserve sparse representation
4. Should convert to most efficient format for common operations (e.g. mget, inner-product)

Protocol for construction of a permutation matrix.

Protocol for QR decomposition

Protocol to reshape matrices. Should support any new shape allowed by the implementation.
Must preserve row-major ordering of matrix elements.
If the original matrix is mutable, must return a new mutable copy of data.
If the new shape has less elements than the original shape, it is OK to truncate the remaining elements.
If the new shape requires more elements than the original shape, should throw an exception.

Rotates an array along a specified dimension by the given number of places.

Rotating a dimension that does not exist has no effect on the array.

Rotates an array using the specified shifts for each dimension.

shifts may be any sequence of integer shift amounts.

Protocol to support construction of row and column matrices from 1D vectors.

A vector of length N should be converted to a 1xN or Nx1 matrix respectively.

Should throw an error if the data is not a 1D vector

Protocol for elementary row operations

Protocol for row setting. Should set a dimension 0 (row) slice to thegiven row value.

Protocol to test if two arrays have the same shape. Implementations may have an optimised
method for shape equality tests, and this is a frequently required operations so it may
make sense to provide an optimised implementation.

Protocol to support the mutable scale-add! operation. This is a common operation that may be 
optimised by the underlying implementation. Implementations should consider extra optimisations for
specific constant values e.g. 0.0 and 1.0 but this is not mandatory.

Protocol for the sel function. See the docstring for clojure.core.matrix/select for
more information on possible argument values.

Protocol for the sel function. Like PSelect, but guarantees an mutable view. 

If not supported by the implementation, may return nil to indicate that a default mutable view
should be created.

Protocol for setting the elements of an array returned by (select a args) to values.
See the docstring for clojure.core.matrix/select for more information on possible argument values.

Rotates an array using the specified shifts for each dimension. Newly shifted in elements
should be filled with the default scalar value (usually zero).

Protocol for concatenating / joining arrays.

Protocol for concatenating / joining arrays.

Returns the row-major slices of the array as a sequence.

These must be views or immutable sub-arrays for higher order slices, or scalars
for the slices of a 1D vector.

The default implementation uses get-major-slice-view to obtain the slices.

Returns slices of the array as a sequence.

These must be views or immutable sub-arrays for higher order slices, or scalars
for the slices of a 1D vector.

Protocol for quick view access into a row-major slices of an array. If implemented, must return
either a view or an immutable sub-matrix: it must *not* return copied data.

If the matrix is mutable, it must return a mutable view.

The default implementation creates a wrapper view.

Protocol for quick view access into a slices of an array. If implemented, must return
either a view or an immutable sub-matrix: it must *not* return copied data.

If the matrix is mutable, it must return a mutable view.

The default implementation creates a wrapper view.

Returns the row-major slice views of the array.

These must be arrays if the array is mutable, i.e. slices of a 1D vector
must be 0-dimensional mutable arrays.

Protocol for solving linear matrix equation or system of linear scalar equations

Protocol for constructing a sparse array from the given data. Implementations should
consider the possibility that data may be a large lazy sequence, possibly larger than memory, so should ideally
attempt to construct the sparse matrix incrementally without realising the whole sequence at once.

May return nil if no sparse conversion is available.

Protocol for determining if an array is in a sparse format. It is up to the implementation to define
its own sparse formats, but in general the intention should be that a sparse array uses significantly
less storage than an equivalent dense array, assuming a high proportion of zero values in the array.

Protocol for construction of special matrices.

Protocol to support element-wise squaring of a numerical array.

Protocol to get a subarray of another array. dim-ranges should be a sequence of [start len]
pairs, one for each dimension. If a pair is nil, it should be interpreted to take the whole dimension.

Returning a mutable view is preferred, if the implementation supports this.

Protocol for getting a sub-vector view of a vector. Must return a mutable view
if the original vector is mutable. Should throw an exception if the specified
subvector is out of bounds for the target vector.

Protocol to support the summing of all elements in an array.
The array must hold numeric values only, or an exception will be thrown.

Protocol for SVD decomposition

Protocol for array transpose operation

Protocol for mutable 2D matrix transpose in place

Protocol for querying the type of matrix elements. If not provided, the default implementation will
return java.lang.Object, and the matrix object is assumed to accept any type of value.
If a matrix is primitive-backed, it should return the appropriate primitive type e.g. Double/TYPE.

Optional protocol to validate the shape of a matrix. If the matrix has an incorrect shape, should
throw an error. Otherwise it should return the correct shape.

Protocol for comparing two arrays, with the semantics of clojure.core/=.
Must return false if the arrays are not of equal shape, or if any elements are not equal.

Protocol to return an array as a flattened vector of all elements.
Implementations are encouraged to avoid taking a full copy of all data
(e.g. by using structural sharing or views).

Protocol to support common numerical vector operations.

Protocol to support transformation of a vector to another vector. Is equivalent to matrix multiplication 
when 2D matrices are used as transformations. But other transformations are possible, e.g. non-affine 
transformations.

A transformation need not be a core.matrix matrix: other types are permissible

Protocol for counting the number of zeros in a numerical array. Must return an integer value 
representing the precise number of zeros.

Protocol for accessing the scalar value in zero-dimensional arrays. Zero dimensional arrays differ
from scalar values in the following two senses:
 - They may be mutable (in which case set-0d! is expected to work)
 - They are not considered themselves to be scalars. Hence you must use get-0d to access the
   contained scalar value

Protocol for setting the scalar value in zero-dimensional arrays.

Returns truthy if a sequence of arrays all have the same shape.

Checks if an array can contain a specified Java type.