pymel.core.datatypes.Array¶
digraph inheritanced629be2197 { rankdir=TB; ranksep=0.15; nodesep=0.15; size="8.0, 12.0"; "Array" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",URL="../pymel.util.arrays/pymel.util.arrays.Array.html#pymel.util.arrays.Array",style="setlinewidth(0.5)",tooltip="A generic n-dimensional array class using nested lists for storage.",height=0.25,shape=box,fontsize=8]; }
- class Array(...)¶
A generic n-dimensional array class using nested lists for storage.
Arrays can be built from numeric values, iterables, nested lists or other Array instances
>>> Array() Array([]) >>> Array(2) Array([2]) >>> A = Array([[1, 2], [3, 4]]) >>> print A.formated() [[1, 2], [3, 4]] >>> A = Array([1, 2], [3, 4]) >>> print A.formated() [[1, 2], [3, 4]] >>> A = Array([[1, 2]]) >>> print A.formated() [[1, 2]] >>> A = Array([1], [2], [3]) >>> print A.formated() [[1], [2], [3]] >>> A = Array([[[1], [2], [3]]]) >>> print A.formated() [[[1], [2], [3]]]
You can query some Array characteristics with the properties shape, ndim (number of dimensions) and size, the total number of numeric components
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> A.shape (3, 3) >>> A.ndim 2 >>> A.size 9
Arrays are stored as nested lists and derive from the ‘list’ class.
>>> A.data [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])] >>> list(A) [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])]
Initialization from another Array does a shallow copy, not a deepcopy, unless the Array argument is resized / reshaped.
>>> B = Array(A) >>> print B.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B == A True >>> B is A False >>> B[0] is A[0] True >>> C = Array([A]) >>> print C.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> C[0] is A True >>> C[0,0] is A[0] True
You can pass optional shape information at creation with the keyword arguments shape, ndim and size. The provided data will be expanded to fit the desirable shape, either repeating it if it’s a valid sub-array of the requested shape, or padding it with the Array default value (0 unless defined otherwise in an Array sub-class).
Value will be repeated if it is a valid sub-array of the Array requested
>>> A = Array(1, shape=(2, 2)) >>> print A.formated() [[1, 1], [1, 1]]
It will be padded otherwise, with the Array class default value
>>> A = Array(1, 2, shape=(4,)) >>> print A.formated() [1, 2, 0, 0]
Or a combination of both, first pad it to a valid sub-array then repeat it
>>> A = Array(1, 2, shape=(3, 3)) >>> print A.formated() [[1, 2, 0], [1, 2, 0], [1, 2, 0]]
Repeat can occur in any dimension
>>> A = Array([1, 2, 3], shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
TODO : #>>> A = Array([[1], [2], [3]], shape=(3, 3)) #>>> print A.formated() #[[1, 1, 1], # [2, 2, 2], # [3, 3, 3]]
To avoid repetition, you can use a nested list of the desired number of dimensions
>>> A = Array([1,2,3], shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [1, 2, 3], [1, 2, 3]] >>> A = Array([[1,2,3]], shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [0, 0, 0], [0, 0, 0]]
If sub-array and requested array have same number of dimensions, padding with row / columns will be used (useful for the MatrixN sub-class or Array)
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array(A, shape=(4, 4)) >>> print B.formated() [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]]
Initialization will not allow to truncate data, if you provide more arguments than the requested array shape can fit, it will raise an exception. Use an explicit trim / resize or item indexing if you want to extract a sub-array
>>> A = Array([1, 2, 3, 4, 5], shape=(2, 2)) Traceback (most recent call last): ... TypeError: cannot initialize a Array of shape (2, 2) from [1, 2, 3, 4, 5] of shape (5,), as it would truncate data or reduce the number of dimensions
- T¶
The transposed array
- __abs__() <==> abs(a)¶
Element-wise absolute value of a.
>>> A = Array([[complex(1, 2), complex(2, 3)], [complex(4, 5), complex(6, 7)]]) >>> print abs(A).formated() [[2.2360679775, 3.60555127546], [6.40312423743, 9.21954445729]] >>> A = Array(-1, 2, -3) >>> print repr(abs(A)) Array([1, 2, 3])
- __add__(other)¶
a.__add__(b) <==> a+b
Returns the result of the element wise addition of a and b if b is convertible to Array, adds b to every component of a if b is a single numeric value
Note : when the operands are 2 Arrays of different shapes, both are cast to the shape of largest size if possible. Created components are filled with class default value.
Related : See the Array.__coerce__ method
>>> A = Array(range(4), shape=(2, 2)) >>> print (A).formated() [[0, 1], [2, 3]] >>> print (A+1).formated() [[1, 2], [3, 4]] >>> print (A+[1, 2]).formated() [[1, 3], [3, 5]] >>> A = Array(range(9), shape=(3, 3)) >>> M = MatrixN(range(10, 50, 10), shape=(2, 2)) >>> print (A+M).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A+M) MatrixN >>> A = Array(range(10, 50, 10), shape=(2, 2)) >>> M = MatrixN(range(9), shape=(3, 3)) >>> print (A+M).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A+M) MatrixN
- __coerce__(other)¶
coerce(a, b) -> (a1, b1)
Return a tuple consisting of the two numeric arguments converted to a common type and shape, using the same rules as used by arithmetic operations. If coercion is not possible, return NotImplemented.
b is cast to Array when possible
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> nA, nB = coerce(A, 1) >>> print nA.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print nB.formated() [[1, 1, 1], [1, 1, 1], [1, 1, 1]] >>> nA, nB = coerce(A, [1, 2, 3]) >>> print nA.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print nB.formated() [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
Arguments can only be expanded, not truncated to avoid silent loss of data.
>>> A = Array(range(4), shape=(2, 2)) >>> nA, nB = coerce(A, [1, 2, 3, 4, 5]) Traceback (most recent call last): ... TypeError: number coercion failed
TODO : would be more explicit to get : TypeError: Array of shape (2, 2) and Array of shape (5,) cannot be converted to an common Array instance of same shape
Arrays of dissimular shape are cast to same shape when possible, smallest size is cast to largest
>>> A = Array(range(1, 10), shape=(3, 3)) >>> B = Array(range(1, 5), shape=(2, 2)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print B.formated() [[1, 2], [3, 4]] >>> nA, nB = coerce(A, B) >>> print nA.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print nB.formated() [[1, 2, 0], [3, 4, 0], [0, 0, 0]]
When coerce(x, y) is not doable, it defers to coerce(y, x)
>>> nB, nA = coerce(B, A) >>> print nA.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print nB.formated() [[1, 2, 0], [3, 4, 0], [0, 0, 0]]
- And does not raise an excepetion like :
- Traceback (most recent call last):
- ...
TypeError: Array of shape (2, 2) and Array of shape (3, 3) cannot be converted to an common Array instance of same shape
as it could be expected without this __coerce__ mechanism.
When mixing Array derived types, result are cast to the first base class of either argument that accepts both shapes, ie ‘deepest’ derived class is tried first, MatrixN before Array, etc.
>>> A = Array(range(1, 10), shape=(3, 3)) >>> M = MatrixN(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print M.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> nA, nM = coerce(A, M) >>> print repr(nA) MatrixN([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print repr(nM) MatrixN([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> nM, nA = coerce(M, A) >>> print repr(nA) MatrixN([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print repr(nM) MatrixN([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
This allows to implement a common behavior for element-wise arithmetics between Arrays of same or dissimilar shapes, Arrays and types derived from Arrays, Arrays and numerics or iterables of numerics.
All operators on Arrays that take 2 operands and work element-wise follow the following rules :
Operands are cast to Array when possible
>>> A = Array(range(4), shape=(2, 2)) >>> print (A).formated() [[0, 1], [2, 3]] >>> print (A+1).formated() [[1, 2], [3, 4]] >>> print (A+[1, 2]).formated() [[1, 3], [3, 5]]
Operands can only be expanded, not truncated to avoid silent loss of data.
>>> print (A+[1, 2, 3, 4, 5]).formated() Traceback (most recent call last): ... TypeError: unsupported operand type(s) for +: 'Array' and 'list'
- TODO : it would be more explicit to get more specific error messages, like :
- TypeError: Array of shape (2, 2) and Array of shape (5,) cannot be converted to an common Array instance of same shape
Arrays of dissimilar shape are cast to same shape by Array.__coerce__ if possible.
>>> A = Array(range(9), shape=(3, 3)) >>> B = Array(range(10, 50, 10), shape=(2, 2)) >>> print (A+B).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A+B) Array
As Array.__coerce__ cannot truncate data, it will defer to the other operand’s __coerce__ if it exists, then to its ‘right operation’ (here __radd__) method if it exists and is defined for an Array left operand.
>>> A = Array(range(10, 50, 10), shape=(2, 2)) >>> B = Array(range(9), shape=(3, 3)) >>> print (A+B).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A+B) Array
Result is cast to the first applicable Array herited type of either operand
>>> A = Array(range(9), shape=(3, 3)) >>> M = MatrixN(range(10, 50, 10), shape=(2, 2)) >>> print (A+M).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A+M) MatrixN >>> print (M+A).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(M+A) MatrixN
>>> A = Array(range(10, 50, 10), shape=(2, 2)) >>> M = MatrixN(range(9), shape=(3, 3)) >>> print (A+M).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A+M) MatrixN >>> print (M+A).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(M+A) MatrixN
Here result is cast to Array as a MatrixN can’t have 3 dimensions
>>> A = Array(range(10, 190, 10), shape=(2, 3, 3)) >>> M = MatrixN(range(9), shape=(3, 3)) >>> print (A+M).formated() [[[10, 21, 32], [43, 54, 65], [76, 87, 98]], [[100, 111, 122], [133, 144, 155], [166, 177, 188]]] >>> print clsname(A+M) Array >>> print (M+A).formated() [[[10, 21, 32], [43, 54, 65], [76, 87, 98]], [[100, 111, 122], [133, 144, 155], [166, 177, 188]]] >>> print clsname(M+A) Array
There are cases where no type coercion is possible, as it would truncate data or reduce number of dimensions in either way, use an explicit conversion (trim, size, etc.) in that case :
>>> A = Array(range(8), shape=(2, 2, 2)) >>> M = MatrixN(range(9), shape=(3, 3)) >>> print (A+M).formated() Traceback (most recent call last): ... TypeError: unsupported operand type(s) for +: 'Array' and 'MatrixN'
TODO : return some more explicit messages in these cases
- __contains__(value)¶
a.__contains__(b) <==> b in a
Returns True if at least one of the sub-Arrays of a (down to individual components) is equal to b, False otherwise
>>> A = Array(list(range(1, 6))+list(range(4, 0, -1)), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 4], [3, 2, 1]] >>> 5 in A True >>> [1, 2, 3] in A True >>> [1, 2] in A False >>> Array([[1, 2], [4, 5]]) in A False
This behavior is unlike numpy arrays (where it would return True), but like builtin list
>>> A in A False
TODO : #>>> [1, 4, 3] in A #True #>>> [[1], [4], [3]] in A #True
- __delitem__(index)¶
a.__delitem__(index) <==> del a[index]
Delete elements that match index from the Array.
Note : as opposed to a.strip(index), do not collapse dimensions of the Array that end up with only one sub-array.
>>> A = Array(xrange(1, 28), shape=(3, 3, 3)) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> A.shape (3, 3, 3) >>> S = A[0] >>> del A[1] >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> A.shape (2, 3, 3) >>> S == A[0] True >>> S is A[0] True >>> del A[-1] >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> A.shape (1, 3, 3) >>> del A[None, None, 1:3] >>> print A.formated() [[[1], [4], [7]]] >>> A.shape (1, 3, 1) >>> del A[None, 1:3] >>> print A.formated() [[[1]]] >>> A.shape (1, 1, 1) >>> del A[-1] >>> print A.formated() [] >>> A.shape (0,)
- __delslice__(start)¶
deprecated and __setitem__ should accept slices anyway
- __div__(other)¶
a.__div__(b) <==> a/b The division operator (/) is implemented by these methods. The __truediv__() method is used when __future__.division is in effect, otherwise __div__() is used. Returns the result of the element wise division of a by b if b is convertible to Array, divides every component of a by b if b is a single numeric value
- __eq__(other)¶
a.__equ__(b) <==> a == b
Equivalence operator, will only work for exact same type of a and b, check isEquivalent method to have it convert a and b to a common type (if possible).
>>> Array(range(4), shape=(4)) == Array(range(4), shape=(1, 4)) False >>> Array(range(4), shape=(2, 2)) == Array(range(4), shape=(2, 2)) True >>> Array(range(4), shape=(2, 2)) == MatrixN(range(4), shape=(2, 2)) False
- __floordiv__(other)¶
a.__floordiv__(b) <==> a//b Returns the result of the element wise floor division of a by b if b is convertible to Array, performs floor division of every component of a by b if b is a single numeric value
- __getitem__(index)¶
a.__getitem__(index) <==> a[index]
Get Array element from either a single (integer) or multiple (tuple) indices, supports slices.
Note : __getitem__ returns reference that can be modified unless the sub-array had to be reconstructed.
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print repr(A[0]) Array([1, 2, 3]) >>> print repr(A[-1]) Array([7, 8, 9]) >>> print repr(A[0, 0]) 1 >>> print repr(A[-1, -1]) 9
Multiple indices and slices are supported :
>>> B = A[0:2, 0:2] >>> print B.formated() [[1, 2], [4, 5]]
When sub-arrays are not broken / rebuilt by requested indexing, a reference is returned :
>>> B = A[0:2] >>> print B.formated() [[1, 2, 3], [4, 5, 6]] >>> B[0] == A[0] True >>> B[0] is A[0] True
Missing indices are equivalent to slice(None), noted ‘:’, but as with list, a[:] returns a copy of a, not a reference to a.
>>> B = A[0:2, :] >>> print B.formated() [[1, 2, 3], [4, 5, 6]] >>> B[0] == A[0] True >>> B[0] is A[0] False
When sub-arrays are rebuilt, result is a copy.
>>> B = A[:, 0:2] >>> print B.formated() [[1, 2], [4, 5], [7, 8]] >>> print repr(B[:,0]) Array([1, 4, 7]) >>> B[:,0] == A[:, 0] True >>> B[:,0] is A[:, 0] False
Use __setindex__ to change the value of an indexed element in that case
>>> A[:, 0:2] += 10 >>> print A.formated() [[11, 12, 3], [14, 15, 6], [17, 18, 9]]
- __getslice__(start, end)¶
Deprecated and __getitem__ should accept slices anyway
- __iadd__(other)¶
a.__iadd__(b) <==> a += b
In place addition of a and b, see __add__, result must fit a’s type
>>> A = Array(range(9), shape=(3, 3)) >>> M = MatrixN(range(10, 50, 10), shape=(2, 2)) >>> A += M >>> print A.formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(A) Array >>> A = Array(range(9), shape=(3, 3)) >>> M = MatrixN(range(10, 50, 10), shape=(2, 2)) >>> M += A >>> print M.formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(M) MatrixN
Result must be castable to the type of a
>>> A = Array(range(12), shape=(2, 3, 2)) >>> M = MatrixN(range(9), shape=(3, 3)) >>> B = M + A >>> print B.formated() [[[0, 2], [4, 6], [8, 10]], [[12, 14], [16, 9], [10, 11]]] >>> print clsname(B) Array >>> M += A Traceback (most recent call last): ... TypeError: cannot cast a Array of shape (2, 3, 2) to a MatrixN of shape (2, 6), as it would truncate data or reduce the number of dimensions
- __idiv__(other)¶
a.__idiv__(b) <==> a /= b The division operator (/) is implemented by these methods. The __truediv__() method is used when __future__.division is in effect, otherwise __div__() is used. In place division of a by b, see __div__, result must fit a’s type
- __ifloordiv__(other)¶
a.__ifloordiv__(b) <==> a //= b In place true division of a by b, see __floordiv__, result must fit a’s type
- __imod__(other)¶
a.__imod__(b) <==> a %= b In place modulo of a by b, see __mod__, result must fit a’s type
- __imul__(other)¶
a.__imul__(b) <==> a *= b In place multiplication of a and b, see __mul__, result must fit a’s type
- __invert__()¶
a.__invert__() <==> ~a
Element-wise invert of a, as with ‘~’, operator ‘invert’
>>> A = Array(range(4), shape=(2, 2)) >>> print (~A).formated() [[-1, -2], [-3, -4]]
- __ipow__(other, modulo=None)¶
a.__ipow__(b[, modulo]) <==> a**=b or a = (a**b) % modulo In place elevation to power of a by b, see __pow__, result must fit a’s type
- __isub__(other)¶
a.__isub__(b) <==> a -= b In place substraction of a and b, see __sub__, result must fit a’s type
- __iter__(*args, **kwargs) <==> iter(a, *args, **kwargs)¶
Default Array storage class iterator, operates on first axis only
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> [a for a in A] [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])]
- __itruediv__(other)¶
a.__itruediv__(b) <==> a /= b In place true division of a by b, see __truediv__, result must fit a’s type
- __len__() <==> len(a)¶
Length of the first dimension of the array, ie len of the array considered as the top level list, thus len(a) == a.shape[0].
>>> Array(shape=(3, 2)).__len__() 3
- __mod__(other)¶
a.__mod__(b) <==> a%b Returns the result of the element wise modulo of a by b if b is convertible to Array, performs modulo of every component of a by b if b is a single numeric value
- __mul__(other)¶
a.__mul__(b) <==> a*b Returns the result of the element wise multiplication of a and b if b is convertible to Array, multiplies every component of a by b if b is a single numeric value
- __ne__(other)¶
a.__ne__(b) <==> a != b
a.__ne__(b) returns not a.__equ__(b).
>>> Array(range(4), shape=(4)) != Array(range(4), shape=(1, 4)) True >>> Array(range(4), shape=(2, 2)) != Array(range(4), shape=(2, 2)) False >>> Array(range(4), shape=(2, 2)) != MatrixN(range(4), shape=(2, 2)) True
- __neg__()¶
a.__neg__() <==> -a
Element-wise negation of a
>>> A = Array(range(4), shape=(2, 2)) >>> print (-A).formated() [[0, -1], [-2, -3]]
- __neq__(other)¶
a.__ne__(b) <==> a != b
a.__ne__(b) returns not a.__equ__(b).
>>> Array(range(4), shape=(4)) != Array(range(4), shape=(1, 4)) True >>> Array(range(4), shape=(2, 2)) != Array(range(4), shape=(2, 2)) False >>> Array(range(4), shape=(2, 2)) != MatrixN(range(4), shape=(2, 2)) True
- __pos__()¶
a.__pos__() <==> +a
Element-wise positive of a
>>> A = Array(range(4), shape=(2, 2)) >>> print (+A).formated() [[0, 1], [2, 3]]
- __pow__(other, modulo=None)¶
a.__pow__(b[, modulo]) <==> a**b or (a**b) % modulo With two arguments, equivalent to a**b. With three arguments, equivalent to (a**b) % modulo, but may be more efficient (e.g. for longs). Returns the result of the element wise elevation to power of a by b if b is convertible to Array, elevates every component of a to power b if b is a single numeric value
- __radd__(other)¶
a.__radd__(b) <==> b+a
Returns the result of the element wise addition of a and b if b is convertible to Array, adds b to every component of a if b is a single numeric value
Note : when the operands are 2 Arrays of different shapes, both are cast to the shape of largest size if possible. Created components are filled with class default value.
Related : See the Array.__coerce__ method
>>> A = Array(range(4), shape=(2, 2)) >>> print (A).formated() [[0, 1], [2, 3]] >>> print (1+A).formated() [[1, 2], [3, 4]] >>> print ([1, 2]+A).formated() [[1, 3], [3, 5]] >>> A = Array(range(9), shape=(3, 3)) >>> M = MatrixN(range(10, 50, 10), shape=(2, 2)) >>> print (M+A).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(M+A) MatrixN >>> A = Array(range(10, 50, 10), shape=(2, 2)) >>> M = MatrixN(range(9), shape=(3, 3)) >>> print (M+A).formated() [[10, 21, 2], [33, 44, 5], [6, 7, 8]] >>> print clsname(M+A) MatrixN
- __rdiv__(other)¶
a.__rdiv__(b) <==> b/a The division operator (/) is implemented by these methods. The __truediv__() method is used when __future__.division is in effect, otherwise __div__() is used. Returns the result of the element wise division of b by a if b is convertible to Array, replaces every component c of a by b/c if b is a single numeric value
- __reduce__()¶
__reduce__ is defined to allow pickling of Arrays
- __rfloordiv__(other)¶
a.__rfloordiv__(b) <==> b//a Returns the result of the element wise floor division of b by a if b is convertible to Array, replaces every component c of a by b//c if b is a single numeric value
- __rmod__(other)¶
a.__rmod__(b) <==> b%a Returns the result of the element wise modulo of b by a if b is convertible to Array, replaces every component c of a by b%c if b is a single numeric value
- __rmul__(other)¶
a.__mul__(b) <==> b*a Returns the result of the element wise multiplication of a and b if b is convertible to Array, multiplies every component of a by b if b is a single numeric value
- __round__([ndigits]) <==> round(a[, ndigits])¶
Element-wise round to given precision in decimal digits (default 0 digits). This always returns an Array of floating point numbers. Precision may be negative.
>>> A = Array([1.0/x for x in range(1, 10)], shape=(3, 3)) >>> print round(A, 2).formated() [[1.0, 0.5, 0.33], [0.25, 0.2, 0.17], [0.14, 0.13, 0.11]]
- __rpow__(other)¶
a.__rpow__(b[, modulo]) <==> b**a or (b**a) % modulo With two arguments, equivalent to b**a. With three arguments, equivalent to (b**a) % modulo, but may be more efficient (e.g. for longs). Returns the result of the element wise elevation to power of b by a if b is convertible to Array, replaces every component c of a by b elevated to power c if b is a single numeric value
- __rsub__(other)¶
a.__rsub__(b) <==> b-a Returns the result of the element wise substraction of a from b if b is convertible to Array, replace every component c of a by b-c if b is a single numeric value
- __rtruediv__(other)¶
a.__rtruediv__(b) <==> b/a The division operator (/) is implemented by these methods. The __rtruediv__() method is used when __future__.division is in effect, otherwise __rdiv__() is used. Returns the result of the element wise true division of b by a if b is convertible to Array, replaces every component c of a by b/c if b is a single numeric value
- __setitem__(index, value)¶
a.__setitem__(index, value) <==> a[index] = value
Set Array element from either a single (integer) or multiple (tuple) indices, supports slices.
Note : if value is not reshaped / resized, it’s a reference to value that is set at the indexed element, use an explicit deepcopy
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
If value doesn’t have to be rebuilt, the indexed elements will hold a reference to value, otherwise a copy
>>> S = Array([0, 0, 0]) >>> A[0] = S >>> print A.formated() [[0, 0, 0], [4, 5, 6], [7, 8, 9]] >>> A[0] == S True >>> A[0] is S True >>> A[:, 2] = S >>> print A.formated() [[0, 0, 0], [4, 5, 0], [7, 8, 0]] >>> A[:, 2] == S True >>> A[:, 2] is S False
Multiple indices and slices are supported :
>>> A[0] = [2, 4, 6] >>> print A.formated() [[2, 4, 6], [4, 5, 0], [7, 8, 0]] >>> A[1, 1] = 10 >>> print A.formated() [[2, 4, 6], [4, 10, 0], [7, 8, 0]] >>> A[:, -1] = [7, 8, 9] >>> print A.formated() [[2, 4, 7], [4, 10, 8], [7, 8, 9]] >>> A[:, 0:2] += 10 >>> print A.formated() [[12, 14, 7], [14, 20, 8], [17, 18, 9]]
Value is expanded / repeated as necessary to fit the indexed sub-array
>>> A[0:2, 0:2] = 1 >>> print A.formated() [[1, 1, 7], [1, 1, 8], [17, 18, 9]] >>> A[1:3, :] = [1, 2] >>> print A.formated() [[1, 1, 7], [1, 2, 0], [1, 2, 0]] >>> A[0:2, 1:3] = [1, 2] >>> print A.formated() [[1, 1, 2], [1, 1, 2], [1, 2, 0]] >>> A[0:2, 1:3] = [[1], [2]] >>> print A.formated() [[1, 1, 0], [1, 2, 0], [1, 2, 0]]
It cannot be truncated however
>>> A[0] = [1, 2, 3, 4] Traceback (most recent call last): ... ValueError: shape mismatch between value(s) and Array components or sub Arrays designated by the indexing
- __setslice__(start, end, value)¶
Deprecated and __setitem__ should accept slices anyway
- __sub__(other)¶
a.__sub__(b) <==> a-b Returns the result of the element wise substraction of b from a if b is convertible to Array, substracts b from every component of a if b is a single numeric value
- __truediv__(other)¶
a.__truediv__(b) <==> a/b The division operator (/) is implemented by these methods. The __truediv__() method is used when __future__.division is in effect, otherwise __div__() is used. Returns the result of the element wise true division of a by b if b is convertible to Array, performs true division of every component of a by b if b is a single numeric value
- all([axis0[, axis1[, ...]]]) <=> all(a, axis=(axis0, axis1, ...))¶
Returns True if all the components of iterable a evaluate to True. If axis are specified will return an Array of all(x) for x in a.axisiter(*axis).
>>> A = Array([[True,True,True],[False,True,False]]) >>> print A.formated() [[True, True, True], [False, True, False]] >>> A.all() False >>> A.all(0, 1) False >>> A.all(0) Array([False, True, False]) >>> A.all(1) Array([True, False])
- any([axis0[, axis1[, ...]]]) <=> any(a, axis=(axis0, axis1, ...))¶
Returns True if any of the components of iterable a evaluate to True. If axis are specified will return an Array of any(x) for x in a.axisiter(*axis).
>>> A = Array([[False,True,True],[False,True,False]]) >>> print A.formated() [[False, True, True], [False, True, False]] >>> A.any() True >>> A.any(0, 1) True >>> A.any(0) Array([False, True, True]) >>> A.any(1) Array([True, True])
- apicls¶
alias of list
- append(b[, axis=0])¶
Modifies a by appending b at its end, as iterated on axis.
Note : does not work as list append and appends a copy (deepcopy) of b, not a reference to b. However a is appended in place.
Examples:
>>> A = Array([]) >>> print repr(A) Array([]) >>> A.append(1) >>> print A.formated() [1] >>> A.append(2) >>> print A.formated() [1, 2] >>> A = Array([A]) >>> print A.formated() [[1, 2]] >>> A.append([4, 5], axis=0) >>> print A.formated() [[1, 2], [4, 5]] >>> A.append([3, 6], axis=1) >>> print A.formated() [[1, 2, 3], [4, 5, 6]] >>> A.append([7, 8, 9]) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array([A]) >>> B.append(A) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> B[0] == B[1] True >>> B[0] is B[1] False >>> A == B[0] True >>> A is B[0] True >>> B.append([0, 0, 0], axis=1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]], [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]] >>> B.append([0, 0, 0, 1], axis=2) >>> print B.formated() [[[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]], [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]]]
- appended(other, axis=0)¶
a.appended(b[, axis=0]) –> Array
Returns the Array obtained by appending b at the end of a as iterated on axis.
Note : returns a deepcopy of a.appends(b[, axis=0]).
Examples:
>>> A = Array([]) >>> print repr(A) Array([]) >>> A = A.appended(1) >>> print A.formated() [1] >>> A = A.appended(2) >>> print A.formated() [1, 2] >>> A = Array([A]) >>> print A.formated() [[1, 2]] >>> A = A.appended([4, 5], axis=0) >>> print A.formated() [[1, 2], [4, 5]] >>> A = A.appended([3, 6], axis=1) >>> print A.formated() [[1, 2, 3], [4, 5, 6]] >>> A = A.appended([7, 8, 9]) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array([A]).appended(A) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> B[0] == B[1] True >>> B[0] is B[1] False >>> A == B[0] True >>> A is B[0] False >>> B = B.appended([0, 0, 0], axis=1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]], [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]] >>> B = B.appended([0, 0, 0, 1], axis=2) >>> print B.formated() [[[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]], [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]]]
- assign(value)¶
a.assign(b) –> Array
Assigns the value of b to a, equivalent to using the data property : a.data = b. Besides changing a’s value, it also returns the new a to conform to Maya’s api assign.
Note: assign acts as a shallow copy
>>> A = Array(range(1, 5), shape=(2, 2)) >>> B = Array() >>> B.assign(A) Array([[1, 2], [3, 4]]) >>> print B.formated() [[1, 2], [3, 4]] >>> B == A True >>> B is A False >>> B[0] is A[0] True
- axisiter(*args)¶
a.axisiter([axis1[, axis2[, ...]]]) –> ArrayIter
Returns an iterator using a specific axis or list of ordered axis. It is equivalent to transposing the Array using these ordered axis and iterating on the new Array for the remaining sub array dimension
Note : ArrayIter ierators support __len__, __getitem__ and __setitem__
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> [a for a in A] [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])] >>> [a for a in A.axisiter(0)] [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])] >>> [a for a in A.axisiter(1)] [Array([1, 4, 7]), Array([2, 5, 8]), Array([3, 6, 9])] >>> [a for a in A.axisiter(0,1)] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> [a for a in A.axisiter(1,0)] [1, 4, 7, 2, 5, 8, 3, 6, 9]
- blend(b[, weight=0.5]) <==> blend(a, b[, weights=0.5])¶
Returns the result of blending from Array instance u to v according to either a scalar weight where blend will yield a*(1-weight) + b*weight Array, or a an iterable of independent weights.
>>> A = Array(0, shape=(2, 2)) >>> print A.formated() [[0, 0], [0, 0]] >>> B = Array(1, shape=(2, 2)) >>> print B.formated() [[1, 1], [1, 1]] >>> print A.blend(B, weight=0.5).formated() [[0.5, 0.5], [0.5, 0.5]] >>> print blend(A, B).formated() [[0.5, 0.5], [0.5, 0.5]] >>> print blend(A, B, weight=[x/4.0 for x in range(4)]).formated() [[0.0, 0.25], [0.5, 0.75]] >>> print blend(A, B, weight=[[0.0, 0.25],[0.75, 1.0]]).formated() [[0.0, 0.25], [0.75, 1.0]]
- clamp([low=0[, high=1]]) <==> clamp (a, low, high)¶
Returns the result of clamping each component of a between low and high if low and high are scalars, or the corresponding components of low and high if low and high are sequences of scalars
>>> A = Array(range(4), shape=(2, 2)) >>> print A.formated() [[0, 1], [2, 3]] >>> print A.clamp(1, 2).formated() [[1, 1], [2, 2]] >>> print clamp(A, 1, 2).formated() [[1, 1], [2, 2]] >>> print clamp(A, 0.0, [x/4.0 for x in range(4)]).formated() [[0, 0.25], [0.5, 0.75]]
- conjugate() <==> conjugate(a)¶
Returns the element-wise complex.conjugate() of the Array.
>>> A = Array([[complex(1, 2), complex(2, 3)], [complex(4, 5), complex(6, 7)]]) >>> print A.formated() [[(1+2j), (2+3j)], [(4+5j), (6+7j)]] >>> print A.conjugate().formated() [[(1-2j), (2-3j)], [(4-5j), (6-7j)]] >>> print conjugate(A).formated() [[(1-2j), (2-3j)], [(4-5j), (6-7j)]] >>> A = Array(range(1, 5), shape=(2, 2)) >>> print conjugate(A).formated() [[1, 2], [3, 4]]
- copy() <==> copy.copy(a)¶
Returns a shallow copy of a
>>> A = Array(range(1, 10), shape=(3, 3)) >>> B = A.copy() >>> print B.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print B == A True >>> print B is A False >>> print B[0] == A[0] True >>> print B[0] is A[0] True
- count(value)¶
a.count(b) –> int
Returns the number of occurrences of b in a.
>>> A = Array(list(range(1, 6))+list(range(4, 0, -1)), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 4], [3, 2, 1]] >>> A.count(5) 1 >>> A.count(4) 2 >>> A.count([1, 2, 3]) 1 >>> A.count([1, 2]) 0
- data¶
The nested list storage for the Array data
- deepcopy() <==> copy.deepcopy(a)¶
Returns a deep copy of a
>>> A = Array(range(1, 10), shape=(3, 3)) >>> B = A.deepcopy() >>> print B.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> print B == A True >>> print B is A False >>> print B[0] == A[0] True >>> print B[0] is A[0] False
- deleted(*args)¶
a.deleted(index) –> Array
Returns a copy (deepcopy) of a with the elements designated by index deleted, as in a.__delitem__(index).
Note : as opposed to a.stripped(index), do not collapse dimensions of the Array that end up with only one sub-array.
>>> A = Array(xrange(1, 28), shape=(3, 3, 3)) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> A.shape (3, 3, 3) >>> B = A.deleted(1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> B.shape (2, 3, 3) >>> B[0] == A[0] True >>> B[0] is A[0] False >>> B = B.deleted(-1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> B.shape (1, 3, 3) >>> B = B.deleted(None, None, slice(1, 3)) >>> print B.formated() [[[1], [4], [7]]] >>> B.shape (1, 3, 1) >>> B = B.deleted((None, slice(1, 3))) >>> print B.formated() [[[1]]] >>> B.shape (1, 1, 1) >>> B = B.deleted(-1) >>> print B.formated() [] >>> B.shape (0,)
- dist(b, axis0, axis1, ...) <==> dist(a, b[, axis=(axis0, axis1, ...)])¶
Returns the distance between a and b, ie length(b-a, axis)
>>> A = Array([[0.5, 0.5, -0.707],[0.707, -0.707, 0.0]]) >>> print A.formated() [[0.5, 0.5, -0.707], [0.707, -0.707, 0.0]] >>> B = Array([[0.51, 0.49, -0.71],[0.71, -0.70, 0.0]]) >>> print B.formated() [[0.51, 0.49, -0.71], [0.71, -0.7, 0.0]] >>> A.dist(B) 0.016340134638368205 >>> A.dist(B, 0, 1) 0.016340134638368205 >>> A.dist(B, 0) Array([0.0144568322948, 0.00761577310586]) >>> A.dist(B, 1) Array([0.0104403065089, 0.0122065556157, 0.003])
- distanceTo(b) <==> a.dist(b)¶
Equivalent to the dist method, for compatibility with Maya’s API. Does not take axis arguements
- extend(other)¶
a.vstack(b) <==> a.stack(b, axis=0)
Modifies a by concatenating b at its end, as iterated on first axis. For a 2 dimensional Array/MatrixN, it stacks a and b vertically
>>> A = Array([[1, 2], [3, 4]]) >>> print A.formated() [[1, 2], [3, 4]] >>> A.vstack([[5, 6]]) >>> print A.formated() [[1, 2], [3, 4], [5, 6]]
- extended(other)¶
a.vstacked(b) <==> a.stacked(b, axis=0)
Returns the Array obtained by concatenating a and b on first axis. For a 2 dimensional Array/MatrixN, it stacks a and b vertically.
>>> A = Array([[1, 2], [3, 4]]) >>> print A.formated() [[1, 2], [3, 4]] >>> A = A.vstacked([[5, 6]]) >>> print A.formated() [[1, 2], [3, 4], [5, 6]]
- fill([value])¶
Fills the array in place with the given value, if no value is given a is filled with the default class values
Note : value is copied (deepcopy) as many times as it is inserted in a, not referenced.
Examples:
>>> A = Array(shape=(3, 3)) >>> print A.formated() [[0, 0, 0], [0, 0, 0], [0, 0, 0]] >>> A.fill(10) >>> print A.formated() [[10, 10, 10], [10, 10, 10], [10, 10, 10]] >>> A.fill() >>> print A.formated() [[0, 0, 0], [0, 0, 0], [0, 0, 0]] >>> A.fill([1, 2]) >>> print A.formated() [[1, 2, 0], [1, 2, 0], [1, 2, 0]] >>> A.fill([1, 2, 3]) >>> print A.formated() [[1, 2, 3], [1, 2, 3], [1, 2, 3]] >>> A[0] == A[-1] True >>> A[0] is A[-1] False
- filled(value=None)¶
a.filled([value]) –> Array
Returns a copy (deepcopy) of a, filled with value for a’s shape. If no value is given, a is filled with the class default. value will be expended with the class default values to the nearest matching sub array of a, then repeated. value can’t be truncated and will raise an error if of a size superior to the size of the nearest matching sub array of the class, to avoid improper casts.
Note : value is copied (deepcopy) as many times as it is inserted in a, not referenced.
Examples:
>>> Array(shape=(5,)).filled([0, 1, 2]) Array([0, 1, 2, 0, 0]) >>> Array(shape=(5,)).filled(2) Array([2, 2, 2, 2, 2]) >>> print Array(shape=(2, 2)).filled(1).formated() [[1, 1], [1, 1]] >>> A = Array(shape=(3, 3)).filled([1, 2, 3]) >>> print A.formated() [[1, 2, 3], [1, 2, 3], [1, 2, 3]] >>> A[0] == A[-1] True >>> A[0] is A[-1] False >>> A = Array(shape=(3, 3)).filled([1, 2]) >>> print A.formated() [[1, 2, 0], [1, 2, 0], [1, 2, 0]] >>> Array(shape=(2, 2)).filled([1, 2, 3]) Traceback (most recent call last): ... ValueError: value of shape (3,) cannot be fit in a Array of shape (2, 2), some data would be lost
- fit(b)¶
Fits the Array b in a. For every component of a that exists in b (there is a component of same coordinates in b), replace it with the value of the corresponding component in b. Both Arrays a and b must have same number of dimensions.
Note : copies (deepcopy) of b sub-arrays are fit in a, not references, but modification of a is done in-place.
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array(shape=(4, 3)) >>> print B.formated() [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] >>> S = B[-1] >>> B.fit(A) >>> print B.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] >>> B[0] == A[0] True >>> B[0] is A[0] False >>> S == B[-1] True >>> S is B[-1] True >>> B = Array(shape=(4, 4)) >>> B.fit(A) >>> print B.formated() [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]] >>> B = Array(shape=(2, 2)) >>> B.fit(A) >>> print B.formated() [[1, 2], [4, 5]]
- fitted(other)¶
a.fitted(b) –> Array
Returns the result of fitting the Array b in a. For every component of a that exists in b (there is a component of same coordinates in b), replace it with the value of the corresponding component in b. Both Arrays a and b must have same number of dimensions.
Note : returns a copy (deepcopy) of a.fit(b)
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array(shape=(4, 3)) >>> print B.formated() [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] >>> C = B.fitted(A) >>> print C.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] >>> C[0] == A[0] True >>> C[0] is A[0] False >>> C[-1] == B[-1] True >>> C[-1] is B[-1] False >>> B = Array(shape=(4, 4)).fitted(A) >>> print B.formated() [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]] >>> B = Array(shape=(2, 2)).fitted(A) >>> print B.formated() [[1, 2], [4, 5]]
- flat¶
a.flat –> ArrayIter
Flat iterator on all components of the Array
Note : ArrayIter iterators support __len__, __getitem__ and __setitem__
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> [a for a in A] [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])] >>> [a for a in A.flat] [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> A.flat[5:10] = [4, 3, 2, 1] >>> print A.formated() [[1, 2, 3], [4, 5, 4], [3, 2, 1]]
- formated()¶
a.formated() –> str
Returns a string representing a formated output of Array a
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- get()¶
a.get() –> Tuple
Returns a’s internally stored value as a nested tuple, a raw dump of the stored numeric components.
>>> A = Array(range(1, 5), shape=(2, 2)) >>> print A.get() ((1, 2), (3, 4))
- hstack(b) <==> a.stack(b, axis=-1)¶
Modifies a by concatenating b at its end, as iterated on last axis. For a 2 dimensional Array/MatrixN, it stacks a and b horizontally.
>>> A = Array([[1, 2], [4, 5]]) >>> print A.formated() [[1, 2], [4, 5]] >>> A.hstack([[3], [6]]) >>> print A.formated() [[1, 2, 3], [4, 5, 6]]
- hstacked(b) <==> a.stacked(b, axis=-1)¶
Returns the Array obtained by concatenating a and b on last axis. For a 2 dimensional Array/MatrixN, it stacks a and b horizontally.
>>> A = Array([[1, 2], [4, 5]]) >>> print A.formated() [[1, 2], [4, 5]] >>> A = A.hstacked([[3], [6]]) >>> print A.formated() [[1, 2, 3], [4, 5, 6]]
- imag()¶
a.real() <==> real(a)
Returns the element-wise complex imaginary part of the Array.
>>> A = Array([[complex(1, 2), complex(2, 3)], [complex(4, 5), complex(6, 7)]]) >>> print A.formated() [[(1+2j), (2+3j)], [(4+5j), (6+7j)]] >>> print A.imag().formated() [[2.0, 3.0], [5.0, 7.0]] >>> print imag(A).formated() [[2.0, 3.0], [5.0, 7.0]] >>> A = Array(range(1, 5), shape=(2, 2)) >>> print imag(A).formated() [[0, 0], [0, 0]]
- index(value)¶
a.index(b) –> int or tuple
Returns the index of the first occurrence of b in a.
>>> A = Array(list(range(1, 6))+list(range(4, 0, -1)), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 4], [3, 2, 1]] >>> A.index(5) (1, 1) >>> A.index(4) (1, 0) >>> A.index([1, 2, 3]) (0,) >>> A.index([1, 2]) Traceback (most recent call last): ... ValueError: Array.index(x): x not in Array
- isEquivalent(other, tol=9.313225746154785e-10)¶
a.isEquivalent(b[, tol]) –> bool
Returns True if both arguments have same shape and distance between both Array arguments is inferior or equal to tol.
>>> A = Array([[0.5,0.5,-0.707],[0.707,-0.707,0]]) >>> B = Array([[0.51,0.49,-0.71],[0.71,-0.70,0]]) >>> C = Array([[0.501,0.499,-0.706],[0.706,-0.708,0.01]]) >>> A.dist(B) 0.016340134638368205 >>> A.dist(C) 0.010246950765959599 >>> A.isEquivalent(C, 0.015) True >>> A.isEquivalent(B, 0.015) False >>> A.isEquivalent(B, 0.020) True
- length(axis0, axis1, ...) <==> length(a[, axis=(axis0, axis1, ...)])¶
Returns length of a, sqrt(a*a) or the square root of the sum of x*x for x in a if a is an iterable of numeric values. If a is an Array and axis are specified will return a list of length(x) for x in a.axisiter(*axis).
>>> A = Array([[0.5,0.5,-0.707],[0.707,-0.707,0.0]]) >>> print A.formated() [[0.5, 0.5, -0.707], [0.707, -0.707, 0.0]] >>> round(A.length(), 7) 1.4140534 >>> round(A.length(0,1), 7) 1.4140534 >>> A.length(0) Array([0.99992449715, 0.999848988598]) >>> A.length(1) Array([0.865938219505, 0.865938219505, 0.707])
- max([axis0[, axis1[, ...[, key=func]]]]) <==> max(a[, key=func[, axis=(axis0, axis1, ...)]])¶
Returns the greatest component of a. If axis are specified will return an Array of element-wise max(x) for x in a.axisiter(*axis).
>>> A = Array([[6,3,4],[1,5,0.5]]) >>> print A.formated() [[6, 3, 4], [1, 5, 0.5]] >>> A.max() 6 >>> A.max(0,1) 6 >>> A.max(0) Array([6, 5, 4]) >>> A.max(1) Array([6, 5])
- min([axis0[, axis1[, ...[, key=func]]]]) <==> min(a[, key=func[, axis=(axis0, axis1, ...)]])¶
Returns the smallest component of a. If axis are specified will return an Array of element-wise min(x) for x in a.axisiter(*axis).
>>> A = Array([[6,3,4],[1,5,0.5]]) >>> print A.formated() [[6, 3, 4], [1, 5, 0.5]] >>> A.min() 0.5 >>> A.min(0, 1) 0.5 >>> A.min(0) Array([1, 3, 0.5]) >>> A.min(1) Array([3, 0.5])
- ndim¶
Number of dimensions of the Array
- normal(axis0, axis1, ...) <==> normal(a[, axis=(axis0, axis1, ...)])¶
Returns a normalized copy of self: self/self.length(axis0, axis1, ...).
>>> A = Array([[0.5,0.5,-0.707],[0.707,-0.707,0.0]]) >>> print A.formated() [[0.5, 0.5, -0.707], [0.707, -0.707, 0.0]] >>> print A.normal().formated() [[0.353593437318, 0.353593437318, -0.499981120367], [0.499981120367, -0.499981120367, 0.0]] >>> print A.normal(0,1).formated() [[0.353593437318, 0.353593437318, -0.499981120367], [0.499981120367, -0.499981120367, 0.0]] >>> print A.normal(0).formated() [[0.5, 0.5, -0.707], [0.707, -0.707, 0.0]] >>> print A.normal(1).formated() [[0.577408397894, 0.577408397894, -1.0], [0.816455474623, -0.816455474623, 0.0]]
- normalize(*args)¶
Performs an in place normalization of self
- prod([axis0[, axis1[, ...[, start=0]]]]) <=> prod(a, start=start, axis=(axis0, axis1, ...))¶
Returns the product of all the components of a, an iterable of values that support the mul operator, times start. If axis are specified will return an Array of prod(x) for x in a.axisiter(*axis).
>>> A = Array([[1,2,3],[4,5,6]]) >>> print A.formated() [[1, 2, 3], [4, 5, 6]] >>> A.prod() 720 >>> A.prod(0, 1) 720 >>> A.prod(0) Array([4, 10, 18]) >>> A.prod(1) Array([6, 120])
- ravel() <==> Array(a.flat)¶
Returns that Array flattened as to a one-dimensional array.
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print repr(A.ravel()) Array([1, 2, 3, 4, 5, 6, 7, 8, 9])
- real() <==> real(a)¶
Returns the element-wise complex real part of the Array.
>>> A = Array([[complex(1, 2), complex(2, 3)], [complex(4, 5), complex(6, 7)]]) >>> print A.formated() [[(1+2j), (2+3j)], [(4+5j), (6+7j)]] >>> print A.real().formated() [[1.0, 2.0], [4.0, 6.0]] >>> print real(A).formated() [[1.0, 2.0], [4.0, 6.0]] >>> A = Array(range(1, 5), shape=(2, 2)) >>> print real(A).formated() [[1, 2], [3, 4]]
- reshape(shape=None)¶
a.reshaped(shape) <==> a.shape = shape
Performs in-place reshape of array a according to the shape argument without changing the Array’s size (total number of components).
Note : as opposed to trim, reshape will reshuffle components and thus not preserve sub-arrays identity.
Examples :
>>> A = Array(range(1, 17), shape=(4, 4)) >>> print A.formated() [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] >>> S = A[0] >>> A.reshape(shape=(2, 2, 4)) >>> print A.formated() [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]] >>> S == A[0, 0] True >>> S is A[0, 0] False
- reshaped(shape=None)¶
a.reshaped(shape) –> Array
Returns a copy the Array as reshaped according to the shape argument, without changing the Array’s size (total number of components)
Examples :
>>> A = Array(range(1, 17), shape=(4, 4)) >>> print A.formated() [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] >>> B = A.reshaped(shape=(2, 2, 4)) >>> print B.formated() [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]] >>> A[0] == B[0, 0] True >>> A[0] is B[0, 0] False
- resize([shape[, value]])¶
Performs in-place resize of array a according to the shape argument. An optional value argument can be passed and will be used to fill the newly created components if the resize results in a size increase, otherwise the Array class default values are used.
Note : as opposed to trim, resize will reshuffle components and thus not preserve sub-arrays identity.
Examples :
>>> A = Array(range(1, 17), shape=(4, 4)) >>> print A.formated() [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] >>> S = A[0] >>> A.resize(shape=(2, 2, 4)) >>> print A.formated() [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]] >>> S == A[0, 0] True >>> S is A[0, 0] False >>> A.resize(shape=(2, 3, 3)) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 0, 0]]] >>> A.resize(shape=(4, 5), value=1) >>> print A.formated() [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 0, 0, 1, 1]]
- resized(shape=None, value=None)¶
a.resized([shape [, value]]) –> Array
Returns a copy of the Array resized according to the shape argument. An optional value argument can be passed and will be used to fill the extra components of the new Array if the resize results in a size increase, otherwise the Array class default values are used.
Examples :
>>> A = Array(range(1, 17), shape=(4, 4)) >>> print A.formated() [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] >>> B = A.resized(shape=(2, 2, 4)) >>> print B.formated() [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]] >>> A[0] == B[0, 0] True >>> A[0] is B[0, 0] False >>> B = B.resized(shape=(2, 3, 3)) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 0, 0]]] >>> B = B.resized(shape=(4, 5), value=1) >>> print B.formated() [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 0, 0, 1, 1]]
- shape¶
a.shape – tuple
Shape of the Array (number of dimensions and number of components in each dimension).
It can be queried, or set to change the Array’s shape similarly to the reshape method.
>>> A = Array(range(1, 17), shape=(4, 4)) >>> print A.formated() [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] >>> S = A[0] >>> A.shape=(2, 2, 4) >>> print A.formated() [[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]] >>> A.shape=(4, 4) >>> print A.formated() [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
Related : see Array.reshape method.
- size¶
Total size of the Array (number of individual components)
- sqlength(axis0, axis1, ...) <==> sqlength(a[, axis=(axis0, axis1, ...)])¶
Returns square length of a, ie a*a or the sum of x*x for x in a if a is an iterable of numeric values. If a is an Array and axis are specified will return a list of sqlength(x) for x in a.axisiter(*axis).
>>> A = Array([[0.5,0.5,-0.707],[0.707,-0.707,0.0]]) >>> print A.formated() [[0.5, 0.5, -0.707], [0.707, -0.707, 0.0]] >>> A.sqlength() 1.999547 >>> A.sqlength(0,1) 1.999547 >>> A.sqlength(0) Array([0.999849, 0.999698]) >>> A.sqlength(1) Array([0.749849, 0.749849, 0.499849])
- stack(other, axis=0)¶
a.stack(b[, axis=0]) –> Array
Modifies a by concatenating b at its end, as iterated on axis.
Note : stacks a copy (deepcopy) of b, not a reference to b. However a is modified in place.
Examples:
>>> A = Array([]) >>> print repr(A) Array([]) >>> A.stack([1]) >>> print A.formated() [1] >>> A.stack([2]) >>> print A.formated() [1, 2] >>> A = Array([A]) >>> print A.formated() [[1, 2]] >>> A.stack([[4, 5]], axis=0) >>> print A.formated() [[1, 2], [4, 5]] >>> A.stack([[3], [6]], axis=1) >>> print A.formated() [[1, 2, 3], [4, 5, 6]] >>> A.stack([[7, 8, 9]]) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array([A]) >>> B.stack(B) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> B[0] == B[1] True >>> B[0] is B[1] False >>> A == B[0] True >>> A is B[0] True >>> B.stack([[[0, 0, 0]], [[0, 0, 0]]], axis=1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]], [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]] >>> B.stack([[[0], [0], [0], [1]], [[0], [0], [0], [1]]], axis=2) >>> print B.formated() [[[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]], [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]]]
- stacked(other, axis=0)¶
a.stacked(b[, axis=0]) –> Array
Returns the Array obtained by concatenating a and b on axis.
Note : returns a deepcopy of a.stack(b[, axis=0]).
Examples:
>>> A = Array([]) >>> print repr(A) Array([]) >>> A = A.stacked([1]) >>> print A.formated() [1] >>> A = A.stacked([2]) >>> print A.formated() [1, 2] >>> A = Array([A]) >>> print A.formated() [[1, 2]] >>> A = A.stacked([[4, 5]], axis=0) >>> print A.formated() [[1, 2], [4, 5]] >>> A = A.stacked([[3], [6]], axis=1) >>> print A.formated() [[1, 2, 3], [4, 5, 6]] >>> A = A.stacked([[7, 8, 9]]) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = Array([A]) >>> B = B.stacked(B) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]] >>> B[0] == B[1] True >>> B[0] is B[1] False >>> A == B[0] True >>> A is B[0] False >>> B = B.stacked([[[0, 0, 0]], [[0, 0, 0]]], axis=1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]], [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]] >>> B = B.stacked([[[0], [0], [0], [1]], [[0], [0], [0], [1]]], axis=2) >>> print B.formated() [[[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]], [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 1]]]
- strip(index)¶
Strip the elements designated by index from a.
Note : as opposed to a.__delete__(index), will collapse dimensions of the Array that end up with only one sub-array.
>>> A = Array(xrange(1, 28), shape=(3, 3, 3)) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> A.shape (3, 3, 3) >>> S = A[0] >>> A.strip(1) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> S == A[0] True >>> S is A[0] True >>> A.strip(-1) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> S == A True >>> S is A False >>> S[0] == A[0] True >>> S[0] is A[0] True >>> A.strip(None, slice(1,3)) >>> print A.formated() [[1], [4], [7]] >>> A.strip(-1) >>> print A.formated() [[1], [4]] >>> A.strip(-1) >>> print A.formated() [1] >>> A.strip(-1) >>> print A.formated() []
- stripped(*args)¶
a.stripped(index) –> Array
Returns a copy (deepcopy) of a with the elements designated by index stripped, as in a.strip(index)
Note : as opposed to a.deleted(index), will collapse dimensions of the Array that end up with only one sub-array.
>>> A = Array(xrange(1, 28), shape=(3, 3, 3)) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> A.shape (3, 3, 3) >>> B = A.stripped(1) >>> print B.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> B[0] == A[0] True >>> B[0] is A[0] False >>> B = B.stripped(-1) >>> print B.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B == A[0] True >>> B is A[0] False >>> B[0] == A[0, 0] True >>> B[0] is A[0,0] False >>> B = B.stripped(None, slice(1,3)) >>> print B.formated() [[1], [4], [7]] >>> B = B.stripped(-1) >>> print B.formated() [[1], [4]] >>> B = B.stripped(-1) >>> print B.formated() [1] >>> B = B.stripped(-1) >>> print B.formated() []
- subiter(dim=None)¶
a.subiter([dim=None]) –> ArrayIter
Returns an iterator on all sub Arrays for a specific sub Array number of dimension.
a.subiter(0) is equivalent to a.flat: lista sub-arrays of dimension 0, ie components a.subiter() is equivalent to self.subiter(self.ndim-1) and thus to self.__iter__()
Note : ArrayIter iterators support __len__, __getitem__ and __setitem__
>>> A = Array(range(1, 28), shape=(3, 3, 3)) >>> print A.formated() [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[10, 11, 12], [13, 14, 15], [16, 17, 18]], [[19, 20, 21], [22, 23, 24], [25, 26, 27]]] >>> [a for a in A.subiter(0)] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27] >>> [a for a in A.subiter(1)] [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9]), Array([10, 11, 12]), Array([13, 14, 15]), Array([16, 17, 18]), Array([19, 20, 21]), Array([22, 23, 24]), Array([25, 26, 27])] >>> [a for a in A.subiter(2)] [Array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), Array([[10, 11, 12], [13, 14, 15], [16, 17, 18]]), Array([[19, 20, 21], [22, 23, 24], [25, 26, 27]])] >>> [a for a in A.subiter(3)] Traceback (most recent call last): ... ValueError: can only iterate for a sub-dimension inferior to Array's number of dimensions 3
- sum([axis0[, axis1[, ...[, start=0]]]]) <=> sum(a, start=start, axis=(axis0, axis1, ...))¶
Returns the sum of all the components of a, plus start. If axis are specified will return an Array of sum(x) for x in a.axisiter(*axis), else will sum on all axis of a.
>>> A = Array([[1,2,3],[4,5,6]]) >>> print A.formated() [[1, 2, 3], [4, 5, 6]] >>> A.sum() 21 >>> A.sum(0, 1) 21 >>> A.sum(0) Array([5, 7, 9]) >>> A.sum(1) Array([6, 15])
- tolist()¶
a.tolist() –> list
Returns that Array converted to a nested list
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print repr(A) Array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print repr(list(A)) [Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])] >>> print repr(A.tolist()) [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- totuple()¶
a.totuple() –> tuple
Returns that Array converted to a nested tuple
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print repr(A) Array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> print repr(tuple(A)) (Array([1, 2, 3]), Array([4, 5, 6]), Array([7, 8, 9])) >>> print repr(A.totuple()) ((1, 2, 3), (4, 5, 6), (7, 8, 9))
- transpose(*args)¶
a.transpose([axis0[, axis1[, ...]]]) –> Array
Returns a reordered / transposed along the specified axes. If no axes are given,or None is passed, switches the complete axes order. For a 2-d array, this is the usual matrix transpose.
>>> A = Array(range(18), shape=(2,3,3)) >>> print A.formated() [[[0, 1, 2], [3, 4, 5], [6, 7, 8]], [[9, 10, 11], [12, 13, 14], [15, 16, 17]]] >>> print A.transpose().formated() [[[0, 9], [3, 12], [6, 15]], [[1, 10], [4, 13], [7, 16]], [[2, 11], [5, 14], [8, 17]]] >>> print A.transpose(0,2,1).formated() [[[0, 3, 6], [1, 4, 7], [2, 5, 8]], [[9, 12, 15], [10, 13, 16], [11, 14, 17]]]
>>> B=MatrixN(range(9), shape=(3, 3)) >>> print B.formated() [[0, 1, 2], [3, 4, 5], [6, 7, 8]] >>> print B.transpose().formated() [[0, 3, 6], [1, 4, 7], [2, 5, 8]]
- trim(shape)¶
Performs in-place trimming of array a to given shape. An optional value argument can be passed and will be used to fill the newly created components if the resize results in a size increase.
Note : a is modified in-place
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> S = A[0] >>> A.trim(shape=(4, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] >>> S == A[0] True >>> S is A[0] True >>> A.trim(shape=(4, 4)) >>> print A.formated() [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]] >>> A.trim(shape=(2, 2)) >>> print A.formated() [[1, 2], [4, 5]]
- trimmed(shape=None, value=None)¶
a.trimmed([shape [, value]]) –> Array
Returns the Array as “trimmed”, re-sized according to the shape argument. The difference with a resize is that each dimension will be resized individually, thus the shape argument must have the same number of dimensions as the Array a. A value of -1 or None for a shape dimension size will leave it unchanged. An optional value argument can be passed and will be used to fill the newly created components if the trimmed results in a size increase, otherwise the class default values will be used to fill new components
Note : returns a copy (deepcopy) of a.trim([shape [, value]])
>>> A = Array(range(1, 10), shape=(3, 3)) >>> print A.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9]] >>> B = A.trimmed(shape=(4, 3)) >>> print B.formated() [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] >>> B[0] == A[0] True >>> B[0] is A[0] False >>> B = A.trimmed(shape=(4, 4)) >>> print B.formated() [[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]] >>> B = A.trimmed(shape=(2, 2)) >>> print B.formated() [[1, 2], [4, 5]]
- vstack(b) <==> a.stack(b, axis=0)¶
Modifies a by concatenating b at its end, as iterated on first axis. For a 2 dimensional Array/MatrixN, it stacks a and b vertically
>>> A = Array([[1, 2], [3, 4]]) >>> print A.formated() [[1, 2], [3, 4]] >>> A.vstack([[5, 6]]) >>> print A.formated() [[1, 2], [3, 4], [5, 6]]
- vstacked(b) <==> a.stacked(b, axis=0)¶
Returns the Array obtained by concatenating a and b on first axis. For a 2 dimensional Array/MatrixN, it stacks a and b vertically.
>>> A = Array([[1, 2], [3, 4]]) >>> print A.formated() [[1, 2], [3, 4]] >>> A = A.vstacked([[5, 6]]) >>> print A.formated() [[1, 2], [3, 4], [5, 6]]