Returns the element(s) at single-index idx or at multi-index idx,
idx2, idx3, …. If the index(es) is beyond the range, then it
will raise an index error.
If idx is an IRange or an array of
boolean values (a mask) or an array of indices
(an indirect) or All, then it will return a column vector
(if $RowOrder is false) or a row vector (if
$RowOrder is true). If idx is an
Integer, then it will return a single element. If idx is
omitted, the it will return a copy of the tensor. For IRange, mask and indirect, the
order is determined by Tnsr#row_order?. For
mask and indirect, the size of mask/indirect array should
be less than or equal to Tnsr#size.
For indirect, the indices in idx cannot be repeated. If
idx is equal to All, then it will return all the elements
(as a column or row vector).
If idx, idx2, idx3, … are several IRange ’s or several arrays of
boolean values (masks) or several arrays of indices
(indirects), then it will return a new tensor. If idx, idx2, idx3,
… are several Integer’s, then it will return a
single element. When they are several IRange
’s, they can be mixed with Integer, All and empty
array. When they are several masks, then can be mixed with All
and empty array. When they are several indirects, they can be mixed with
All and empty array. (In multi-index, for any argument
idxY, if idxY is an array, the first element idxY[0]
will determine if it is a mask or indirect. And in
multi-index, the empty array is equivalent to All, whereas in
single-index, the empty array means no element is selected.)
Examples for the many forms:
t = Tsr.s([2, 4, 2], :-) {|i, m| m[0] * 4 + m[1] + m[2] * 10}
=>
mtrx{:,:,1} (of size 2 x 4 = 8; index starts at 1) =
[ 15 16 17 18
19 20 21 22 ]
mtrx{:,:,2} (of size 2 x 4 = 8; index starts at 9) =
[ 25 26 27 28
29 30 31 32 ]
==> Tnsr "object": 2 x 4 x 2 = 16 (C; dft = nil)
(0) No Argument. This will return a copy of the tensor, and the row order
will follow the current value of $RowOrder (unlike the
Tnsr(self)). Also for Ruby objects only the references are
copied.
t[]
=>
mtrx{:,:,1} (of size 2 x 4 = 8; index starts at 1) =
[ 15 16 17 18
19 20 21 22 ]
mtrx{:,:,2} (of size 2 x 4 = 8; index starts at 9) =
[ 25 26 27 28
29 30 31 32 ]
==> Tnsr "object": 2 x 4 x 2 = 16 (C; dft = nil)
(1) Multiple Integers. This will return a single element. If the
number of integers are at least two but fewer than the number of tensor
dimensions, the rest will considered as “Begin“.
t[Tsr::End, Tsr::Begin, Tsr::End]
=> 29
t[Tsr::End, Tsr::Begin]
=> 19
(2) Single Integer. This will return a single element. The
element ordering is based on row_order?.
t[Tsr::Begin + 3]
=> 20
t[Tsr::End - 1]
=> 28
(3) Single “All“. This will return all the elements
as column or row vector, depending on $RowOrder.
$RowOrder = true
t[Tsr::All]
=>
[ 15 19 16 20 17 21 18 22 25 29 26 30 27 31 28 32 ]
==> Tnsr "object": 1 x 16 = 16 (C; dft = nil)
(4) Single IRange. This will return some
elements as column or row vector, depending on $RowOrder. The
element ordering is based on row_order?. Note that with IRange, the elements in tensor are never presented
backward even though the IRange seems
like backward.
t[Tsr::r(Tsr::Begin + 3, 4, Tsr::End)]
=>
[ 20 22 30 32 ]
==> Tnsr "object": 1 x 4 = 4 (C; dft = nil)
t[Tsr::r(Tsr::End - 2, -2, Tsr::Begin + 2)]
=>
[ 20 21 22 29 30 31 ]
==> Tnsr "object": 1 x 6 = 6 (C; dft = nil)
(5) Single Mask. A mask is an Array with values
of true or false. This will return some elements as
column or row vector, depending on $RowOrder. The element
ordering is based on row_order? and only elements with
true values are presented.
t[[false, true, false, true, true]]
=>
[ 19 20 17 ]
==> Tnsr "object": 1 x 3 = 3 (C; dft = nil)
(6) Single Indirect. An indirect is an Array
with values of indices. This will return some elements as column or row
vector, depending on $RowOrder. The element ordering is based on
row_order? and only elements with indices included are presented.
Note that the indices cannot be repeated.
t[[Tsr::End, Tsr::Begin, Tsr::End - 2]]
=>
[ 32 15 31 ]
==> Tnsr "object": 1 x 3 = 3 (C; dft = nil)
(7) Multiple Integers mixed with “All“ (or
empty array). This will return a tensor. If the number of integers and
All’s are at least two but fewer than the number of tensor
dimensions, the rest will considered as “Begin“.
t[Tsr::Begin + 1, Tsr::All] # the second row
=>
[ 19 20 21 22 ]
==> Tnsr "object": 1 x 4 = 4 (C; dft = nil)
t[Tsr::All, Tsr::End] # the last column of the first matrix
=>
[ 18
22 ]
==> Tnsr "object": 2 x 1 = 2 (C; dft = nil)
t[Tsr::All, Tsr::End, Tsr::All] # the last columns
=>
mtrx{:,:,1} (of size 2 x 1 = 2; index starts at 1) =
[ 18
22 ]
mtrx{:,:,2} (of size 2 x 1 = 2; index starts at 3) =
[ 28
32 ]
==> Tnsr "object": 2 x 1 x 2 = 4 (C; dft = nil)
(8) Multiple IRange ’s. This will return a
tensor. They can be mixed with “All“ (or empty
array). If the number of IRange ’s and
All’s are at least two but fewer than the number of tensor
dimensions, the rest will considered as “Begin“.
t[Tsr::All, Tsr.r(Tsr::Begin, 3, Tsr::End), Tsr::All]
=>
mtrx{:,:,1} (of size 2 x 2 = 4; index starts at 1) =
[ 15 18
19 22 ]
mtrx{:,:,2} (of size 2 x 2 = 4; index starts at 5) =
[ 25 28
29 32 ]
==> Tnsr "object": 2 x 2 x 2 = 8 (C; dft = nil)
(9) Multiple Mask’s. This will return a tensor. They can
be mixed with “All“ (or empty array). If the number
of mask’s and All’s are at least two but
fewer than the number of tensor dimensions, the rest will considered as
“Begin“.
t[[false, true], [true, false, true, true]]
=>
[ 19 21 22 ]
==> Tnsr "object": 1 x 3 = 3 (C; dft = nil)
(10) Multiple Indirect’s. This will return a tensor. They
can be mixed with “All“ (or empty array). If the
number of indirect’s and All’s are at least
two but fewer than the number of tensor dimensions, the rest will
considered as “Begin“.
t[[Tsr::End, Tsr::Begin], [Tsr::End, Tsr::End - 1, Tsr::End - 2, Tsr::End - 3]]
=>
[ 22 21 20 19
18 17 16 15 ]
==> Tnsr "object": 2 x 4 = 8 (C; dft = nil)
(11) Mix of all the above. This case may be slower compared to the other
cases.
t[Tsr.r(Tsr::End), [4, 1, 3, 2], [false, true]]
=>
[ 32 29 31 30 ]
==> Tnsr "object": 1 x 4 = 4 (C; dft = nil)
651: def [] ( { idx, { idx2, idx3, ... } } )
652: end
![[+]](../images/find.png "show/hide quicksearch"){kind=small}
