Details
For "one-dimensional" (single-indexed) arrays vectors, sequences, strings etc. the most common slicing operation is extraction of zero or more consecutive elements. If we have a vector containing elements (2, 5, 7, 3, 8, 6, 4, 1), and want to create an array slice from the 3rd to the 6th elements, we get (7, 3, 8, 6). InHistory
The concept of slicing was surely known even before the invention ofTimeline of slicing in various programming languages
1964: PL/I
PL/I provides two facilities for array slicing. * Using ''iSub DEFINING'', an array slice can be declared using ''iSUB'' variables to map specific elements in a "base array" onto elements of the "defined array". iSUBs can define rows, columns, diagonals, or many-to-one mappings. The following example definesY as a one-dimensional slice consisting of the diagonal elements of the two-dimensional array X.
DECLARE X(5,5);
DECLARE Y(5) DEFINED(X(1SUB,1SUB));
A reference to Y(2) is a reference to X(2,2), and so on.
* A slice, called a ''cross-section'', of an array can be referred to by using asterisk as the subscript for one or more dimensions. The following code sets all the elements in the first column of X to zero. One or more subscripts can be specified by asterisks in an expression.
DECLARE X(5,5);
X(*,1)=0;
1966: Fortran 66
The Fortran 66 programmers were only able to take advantage of slicing matrices by row, and then only when passing that row to a subroutine:SUBROUTINE. 1970s Pascal and C had similar restrictions.
1968:
1968:
1970s: MATLAB
: operator implements the stride syntax (lower_bound:upper_bound stride/code>) by generating a vector. 1:5 evaluates as , 2, 3, 4, 5/code>. 1:9:2 evaluates as , 3, 5, 7, 9/code>. A bare : evaluates the same as 1:end, with end determined by context.
Arrays in S and GNU R are always one-based, thus the indices of a new slice will begin with ''one'' for each dimension, regardless of the previous indices. Dimensions with length of ''one'' will be dropped (unless drop = FALSE). Dimension names (where present) will be preserved.
> A <- array(1:60, dim = c(3, 4, 5)) # 3x4x5 three-dimensional or cubic array
> A , 3# 3x4 two-dimensional array along first and second dimensions
1 2 3 4 , 25 28 31 34
, 26 29 32 35
, 27 30 33 36
> A 2:3, 3, drop = FALSE# 3x2x1 cubic array subset (preserved dimensions)
, , 1
1 2 , 28 31
, 29 32
, 30 33
> A 2, 3 # single-dimension array along first dimension
28 29 30
> A , 2, 3# single value
28
1977: Fortran 77
The Fortran 77 standard introduced the ability to slice and concatenate strings:
PROGRAM MAIN
PRINT *, 'ABCDE'(2:4)
END
Produces:
BCD
Such strings could be passed by reference to another subroutine, the length would also be passed transparently to the subroutine as a kind of short dope vector.
SUBROUTINE PRINT S(STR)
CHARACTER *(*)STR
PRINT *, STR
END
PROGRAM MAIN
CALL PRINT S('ABCDE'(2:4))
END
Again produces:
BCD
1983: Ada 83 and above
Ada 83 supports slices for all array types. Like Fortran 77 such arrays could be passed by reference to another subroutine, the length would also be passed transparently to the subroutine as a kind of short dope vector.
with Text_IO;
procedure Main is
Text : String := "ABCDE";
begin
Text_IO.Put_Line (Text (2 .. 4));
end Main;
Produces:
BCD
Note: Since in Ada indices are n-based the term Text (2 .. 4) will result in an Array with the base index of 2.
The definition for Text_IO.Put_Line is:
package Ada.Text_IO is
procedure Put_Line(Item : in String);
The definition for String is:
package Standard is
subtype Positive is Integer range 1 .. Integer'Last;
type String is array(Positive range <>) of Character;
pragma Pack(String);
As Ada supports true negative indices as in it places no special meaning on negative indices. In the example above the term Some_History_Data (-30 .. 30) would slice the History_Data from 31 BC to 30 AD (since there was no year zero, the year number 0 actually refers to 1 BC).
1987: Perl
If we have
@a = (2, 5, 7, 3, 8, 6, 4);
as above, then the first 3 elements, middle 3 elements and last 3 elements would be:
@a ..2 # (2, 5, 7)
@a ..4 # (7, 3, 8)
@a 3..-1 # (8, 6, 4)
Perl supports negative list indices. The -1 index is the last element, -2 the penultimate element, etc.
In addition, Perl supports slicing based on expressions, for example:
@a 3.. $#a # 4th element until the end (3, 8, 6, 4)
@a grep (0...$#a) # 1st, 4th and 7th element (2,3,4)
@a grep (0..$#a) # every 3rd element (7,6)
1991: Python
If you have the following list:
>>> nums = , 3, 5, 7, 8, 13, 20
Then it is possible to slice by using a notation similar to element retrieval:
>>> nums # no slicing
7
>>> nums 3 # from index 0 (inclusive) until index 3 (exclusive)
, 3, 5>>> nums :5 , 5, 7, 8>>> nums 3: , 13, 20
Note that Python allows negative list indices. The index -1 represents the last element, -2 the penultimate element, etc.
Python also allows a step property by appending an extra colon and a value. For example:
>>> nums : , 8, 13, 20>>> nums ::# nums : , 8, 13, 20>>> nums :3# starting at index 0 and getting every third element
, 7, 20>>> nums :5:2# from index 1 until index 5 and getting every second element
, 7
The stride syntax (nums :5:2/code>) was introduced in the second half of the 1990s, as a result of requests put forward by scientific users in the Python "matrix-SIG" (special interest group).
Slice semantics potentially differ per object; new semantics can be introduced when operator overloading the indexing operator. With Python standard lists (which are dynamic arrays), every slice is a copy. Slices of NumPy arrays, by contrast, are views onto the same underlying buffer.
1992: Fortran 90 and above
In Fortran 90, slices are specified in the form
lower_bound:upper_bound stride
Both bounds are inclusive and can be omitted, in which case they default to the declared
array bounds. Stride defaults to 1. Example:
real, dimension(m, n):: a ! declaration of a matrix
print *, a(:, 2) ! second column
print *, a(m, :) ! last row
print *, a(:10, :10) ! leading 10-by-10 submatrix
1994: Analytica
Each dimension of an array value in Analytica is identified by an Index variable. When slicing or subscripting, the syntax identifies the dimension(s) over which you are slicing or subscripting by naming the dimension. Such as:
Index I := 1..5
Index J := A', 'B', 'C'
Variable X := Array(I, J, 10, 20, 30 , 2, 3 ....])
X = 1, J = 'B' -> 20
X = 1-> Array(J, 0, 20, 30
X = 2-> Array(I, 0, 2, ....
X = 1..3
Naming indexes in slicing and subscripting is similar to naming parameters in function calls instead of relying on a fixed sequence of parameters. One advantage of naming indexes in slicing is that the programmer does not have to remember the sequence of Indexes, in a multidimensional array. A deeper advantage is that expressions generalize automatically and safely without requiring a rewrite when the number of dimensions of X changes.
1998: S-Lang
Array slicing was introduced in version 1.0. Earlier versions did not
support this feature.
Suppose that A is a 1-d array such as
A = :50 % A = , 2, 3, ...49, 50
Then an array B of first 5 elements of A may be created using
B = A :4;
Similarly, B may be assigned to an array of the last 5 elements of A via:
B = A -5:;
Other examples of 1-d slicing include:
A 1 % The last element of A
A % All elements of A
A ::2 % All even elements of A
A 1::2 % All odd elements of A
A -1::-2 % All even elements in the reversed order
A [0:3 [10:14">:3">[0:3 [10:14">:3<_a>_[10:14.html" ;"title=":3">[0:3 [10:14">:3">[0:3 [10:14 % Elements 0-3 and 10-14
Slicing of higher-dimensional arrays works similarly:
A[-1, *] % The last row of A
A1:5], [2:7 % 2d array using rows 1-5 and columns 2-7
A5:1:-1], [2:7 % Same as above except the rows are reversed
Array indices can also be arrays of integers. For example, suppose
that I = :9/code> is an array of 10 integers. Then
A /code> is equivalent to an array of the first 10 elements
of A. A practical example of this is a sorting
operation such as:
I = array_sort(A); % Obtain a list of sort indices
B = A % B is the sorted version of A
C = A rray_sort(A) % Same as above but more concise.
1999: D
Consider the array:
int[] a = [2, 5, 7, 3, 8, 6, 4, 1];
Take a slice out of it:
int[] b = a[2 .. 5];
and the contents of b will be [7, 3, 8]. The first index of the slice is inclusive, the second is exclusive.
auto c = a - 4 .. $ - 2
means that the dynamic array c now contains , 6/code> because inside the [] the $ symbol refers to the length of the array.
D array slices are aliased to the original array, so:
b[2] = 10;
means that a now has the contents , 5, 7, 3, 10, 6, 4, 1/code>. To create a copy of the array data, instead of only an alias, do:
auto b = a .. 5dup;
Unlike Python, D slice bounds don't saturate, so code equivalent to this Python code is an error in D:
>>> d = 0, 20, 30>>> d : 5 0, 30
2004: SuperCollider
The programming language SuperCollider implements some concepts from J/ APL. Slicing looks as follows:
a = , 1, 5, 7 // assign an array to the variable a
a ..1 // return the first two elements of a
a .1 // return the first two elements of a: the zero can be omitted
a .. // return the element 3 till last one
a 0, 3 // return the first and the fourth element of a
a 0, 3 = 00, 200 // replace the first and the fourth element of a
a ..= 00, 200 // replace the two last elements of a
// assign a multidimensional array to the variable a
a = 0, 1, 2, 3, 4 , 6, 7, 8, 9 0, 11, 12, 13, 14 5, 16, 17, 18, 19;
a.slice(2, 3); // take a slice with coordinates 2 and 3 (returns 13)
a.slice(nil, 3); // take an orthogonal slice (returns , 8, 13, 18
2005:
fish
A fish (: fish or fishes) is an aquatic animal, aquatic, Anamniotes, anamniotic, gill-bearing vertebrate animal with swimming fish fin, fins and craniate, a hard skull, but lacking limb (anatomy), limbs with digit (anatomy), digits. Fish can ...
Arrays in fish
A fish (: fish or fishes) is an aquatic animal, aquatic, Anamniotes, anamniotic, gill-bearing vertebrate animal with swimming fish fin, fins and craniate, a hard skull, but lacking limb (anatomy), limbs with digit (anatomy), digits. Fish can ...
are always one-based, thus the indices of a new slice will begin with ''one'', regardless of the previous indices.
> set A (seq 3 2 11) # $A is an array with the values 3, 5, 7, 9, 11
> echo $A seq 2) # Print the first two elements of $A
3 5
> set B $A 2 # $B contains the first and second element of $A, i.e. 3, 5
> set -e A B echo $A # Erase the third and fifth elements of $A, print $A
3 5 9
2006: Cobra
Cobra supports Python-style slicing. If you have a list
nums = , 3, 5, 7, 8, 13, 20
then the first 3 elements, middle 3 elements, and last 3 elements would be:
nums 3 # equals , 3, 5nums :5 # equals , 7, 8nums 3: # equals , 13, 20
Cobra also supports slicing-style syntax for 'numeric for loops':
for i in 2 : 5
print i
# prints 2, 3, 4
for j in 3
print j
# prints 0, 1, 2
2006: Windows PowerShell
Arrays are zero-based in PowerShell and can be defined using the comma operator:
PS> $a = 2, 5, 7, 3, 8, 6, 4, 1
PS> # Print the first two elements of $a:
PS> Write-Host -NoNewline $a , 12 5
PS> # Take a slice out of it using the range operator:
PS> Write-Host -NoNewline $a ..57 3 8 6
PS> # Get the last 3 elements:
PS> Write-Host -NoNewline $a 3..-16 4 1
PS> # Return the content of the array in reverse order:
PS> Write-Host -NoNewline $a $a.Length - 1)..0# Length is a property of System.Object[]
1 4 6 8 3 7 5 2
2009: Go
Go supports Python-style syntax for slicing (except negative indices are not supported). Arrays and slices can be sliced. If you have a slice
nums := []int
then the first 3 elements, middle 3 elements, last 3 elements, and a copy of the entire slice would be:
nums 3 // equals []int
nums :5// equals []int
nums[4:] // equals []int
nums[:] // equals []int
Slices in Go are reference types, which means that different slices may refer to the same underlying array.
2010: Cilk Plus
Cilk Plus supports syntax for array slicing as an extension to C and C++.
array_base ower_bound:length[:stride*
Cilk Plus slicing looks as follows:
A stride">ower_bound:length[:stride*
Cilk Plus slicing looks as follows:
A[: // All of vector A
B[2:6">">stride">ower_bound:length[:stride*
Cilk Plus slicing looks as follows:
A[: // All of vector A
B[2:6 // Elements 2 to 7 of vector B
C[:][5] // Column 5 of matrix C
D[0:3:2] // Elements 0, 2, 4 of vector D
Cilk Plus's array slicing differs from Fortran's in two ways:
* the second parameter is the length (number of elements in the slice) instead of the upper bound, in order to be consistent with standard C libraries;
* slicing never produces a temporary, and thus never needs to allocate memory. Assignments are required to be either non-overlapping or perfectly overlapping, otherwise the result is undefined.
2012: JuliaJulia array slicing
is like that of MATLAB, but uses square brackets. Example:
julia> x = rand(4, 3)
4x3 Array:
0.323877 0.186253 0.600605
0.404664 0.894781 0.0955007
0.223562 0.18859 0.120011
0.149316 0.779823 0.0690126
julia> x , 2 # get the second column.
4-element Array:
0.186253
0.894781
0.18859
0.779823
julia> x , : # get the first row.
1x3 Array:
0.323877 0.186253 0.600605
julia> x :2,2:3 # get the submatrix spanning rows 1,2 and columns 2,3
2x2 Array:
0.186253 0.600605
0.894781 0.0955007
See also
*
References
{{DEFAULTSORT:Array Slicing
Arrays
Programming constructs
Articles with example Ada code
Articles with example ALGOL 68 code
Articles with example D code
Articles with example Fortran code
Articles with example Perl code
Articles with example Python (programming language) code
Articles with example BASIC code