Comparison of programming languages (array)

Programming language comparisons

* General comparison
* Assignment
* Basic syntax
* Basic instructions
* Comments
* Control flow
* Foreach loops
* While loops
* For loops
* Do-while
* Exception handling
* Enumerated types
* Generators
* Anonymous functions
* Conditional expressions
* Functional instructions
* Arrays
* Associative arrays
* Scope
* String operations
* String functions
* Higher-order functions
* Type systems
* List comprehension
* Object-oriented programming
* Object-oriented constructors
* Operators

* Evaluation strategy
* List of "Hello World" programs

* Languages with dependent types
* Comparison of type systems

* * *

Comparison of individual languages

* ALGOL 58's influence on ALGOL 60
* ALGOL 60: Comparisons with other languages
* Comparison of ALGOL 68 and C++
* ALGOL 68: Comparisons with other languages
* Compatibility of C and C++
* Comparison of Pascal and Borland Delphi
* Comparison of Object Pascal and C
* Comparison of Pascal and C
* Comparison of Java and C++
* Comparison of C# and Java
* Comparison of C# and Visual Basic .NET
* Comparison of Visual Basic and Visual Basic .NET

* v
* t
* e

This comparison of programming languages (array) compares the features of array data structures or matrix processing for various computer programming languages.

## Contents

* 1 Syntax
* 1.1 Array dimensions
* 1.2 Indexing
* 1.3 Slicing
* 2 Array system cross-reference list
* 3 Vectorized array operations
* 3.1 Mathematical matrix operations
* 4 References

## Syntax

### Array dimensions

The following list contains syntax examples of how to determine the dimensions (index of the first element, the last element or the size in elements).

Note particularly that some languages index from zero while others index from one while others carry no such restriction or even allow indexing by any enumerated type, not just integers.

Languages  | Size  | First  | Last

|
|
|

Ada | name'Length | name'First | name'Last
ALGOL 68 | UPB name \- LWB name+1
2 UPB name \- 2 LWB name+1
etc. | LWB name
2 LWB name
etc. | UPB name

2 UPB name
etc.

APL | ⍴ name
(⍴ name)[index] | ⎕IO | (⍴ name)-~⎕IO
(⍴ name)[index]-~⎕IO
AWK | length | 1 | asorti
C#, Visual Basic .NET, Windows PowerShell, F# | name.Length | name.GetLowerBound(dimension) | name.GetUpperBound(dimension)
CFML  | arrayLen(name)
name.len() | 1 | name.len()
Ch | max(shape(name)) | 0 | max(shape(name))-1
Common Lisp | (length name) | 0 | (1- (length name))
D | name.length | 0 | name.length-1
$-1
Fortran | size(name) | lbound(name) | ubound(name)
Go | len(name) | 0 | len(name) - 1
Haskell | rangeSize (bounds name) | fst (bounds name) | snd (bounds name)
ISLISP | (length name) | 0 | (1- (length name))
Icon | *name | 1 | *name
Cobra, D, Haxe, Java, JavaScript, Scala | name.length | 0 | name.length - 1
J | #name | 0 | <:@#name
Julia | length(name)
size(name) | begin
first.(axes(name)) | end
last.(axes(name))
Lingo | count(name) | 1 | getLast(name)
LiveCode | length(name) | 1
first | -1
last
Lua | #name | 1 by convention; any integer[1] | #name
Mathematica | Length[name] | 1
First[name] | -1
Last[name]
MATLAB, GNU Octave | length(name) | 1 | end
Nim | name.len | name.low[2] | name.high
Oberon | LEN(name) | 0 | LEN(name) - 1
Object Pascal | Length(name) | 0
low(name) | Length(name)-1
high(name)
Objective-C (`NSArray *` only)  | [name count] | 0 | [name count] - 1
OCaml | Array.length name | 0 | Array.length name \- 1
Perl | scalar(@name) | $[ | $#name
PHP | count(name) | 0 | count(name) - 1
PL/I  | dim(name[,dim]) | lbound(name[,dim]) | hbound(name[,dim])
Python | len(name) | 0 | -1
len(name) - 1
R | length(name) | 1 | length(name)
Raku | @name.elems | 0 | @name.end
Red | length? name | name/1
first name | last name
Ruby | name.size | 0
name.first | -1
name.size - 1
name.last
Rust | name.len() | 0 | name.len() - 1
S-Lang  | length(name) | 0 | -1
length(name)-1
Scheme | (vector-length vector) | 0 | (- (vector-length vector) 1)
Smalltalk | name size | 1
name first | name size
name last
Swift | name.count | 0 | name.count - 1
Unicon | *name | 1 | *name
Visual Basic | UBound(name)-LBound(name)+1 | LBound(name) | UBound(name)
Wolfram Language | Length[name] | 1
First[name] | -1
Last[name]
Xojo | UBound(name) | 0 | UBound(name)
XPath/XQuery | count($name) | 1 | count($name)
last()
array:size(name)[3]

### Indexing

The following list contains syntax examples of how to access a single element of an array.

Format  | Languages

|

name[index] or name[index1, index2] etc. | ALGOL 58, ALGOL 60, ALGOL 68, AWK, Julia, Modula, Pascal, Object Pascal, C#, S-Lang[4] Icon, Unicon
name[index] or name[index1; index2] etc.
or index⌷name or index1 index2⌷name etc.  | APL
name[index] | ActionScript, C, CFML, Ch, Cobra, C++, D, Go, Haxe, Java, JavaScript, Lingo, Lua, Nim, Objective-C (`NSArray *`), Perl,[4] PHP, Python,[4] R, Ruby,[4] Rust, Swift
$name[index] | Perl,[4] Windows PowerShell,[4] XPath/XQuery[3]
@name[index] | Raku
name(index) or name(index1, index2) etc.  | Ada, ALGOL W, BASIC, COBOL, Fortran, RPG, GNU Octave, MATLAB, PL/I, Scala, Visual Basic, Visual Basic .NET, Xojo
$name(index) | XPath/XQuery[3]
name.(index) | OCaml
name.[index] | F#, OCaml
name/index | Red
name ! index | Haskell
$name ? index | XPath/XQuery[3]
(vector-ref name index) | Scheme
(aref name index) | Common Lisp
(elt name index) | ISLISP
name[[index]] | Mathematica,[4] Wolfram Language
name at:index | Smalltalk
[name objectAtIndex:index] | Objective-C (`NSArray *` only)
index{name | J
name.item(index) or name @ index[5] | Eiffel

### Slicing

The following list contains syntax examples of how a range of element of an array can be accessed.

In the following table:

* first – the index of the first element in the slice
* last – the index of the last element in the slice
* end – one more than the index of last element in the slice
* len – the length of the slice (= end - first)
* step – the number of array elements in each (default 1)

Format  | Languages

|

name[first:last] | ALGOL 68,[6] Julia, Icon, Unicon
name[first+(⍳len)-⎕IO] | APL
name[first:end:step] | Python[7][8]
name[first:end] | Go
name[first..last] | Pascal, Object Pascal, Delphi, Nim
$name[first..last] | Windows PowerShell
@name[first..last] | Perl[9]
name[first..last]
name[first...end]
name[first, len] | Ruby[8]
copy/part skip name first len | Red
name(first..last) | Ada[6]
name(first:last) | Fortran,[6][7] GNU Octave, MATLAB[6][9]
name[[first;;last;;step]] | Mathematica,[6][7][8] Wolfram Language
name[[first:last]] | S-Lang[6][7][9]
name.[first..step..last] | F#
name.slice(first, end) | Haxe, JavaScript, Scala
name.slice(first, len) | CFML
array_slice(name, first, len) | PHP[8]
(subseq name first end) | Common Lisp
(subseq name first end) | ISLISP
Array.sub name first len | OCaml
[name subarrayWithRange:NSMakeRange(first, len)] | Objective-C (`NSArray *` only)
(first([+i.@(-~)end){name | J
name[first..<end]
name[first...last] | Swift
name copyFrom: first to:last
name copyFrom: first count:len  | Smalltalk
name[first..end] | D, C#[10][11]
name[first..end]
name[first..=last] | Rust
name[first:end] | Cobra
`table.move(name, first, last, 1, {})` | Lua[12]

## Array system cross-reference list

Language | Default
base index | Specifiable
index type[13] | Specifiable
base index  | Bound check | Multidimensional | Dynamically-sized  | Vectorized operations

|
|
|
|
|
|
|

Ada | index type[14] | yes  | yes  | checked  | yes  | init[15] | some, others definable[16]
ALGOL 68 | 1  | no[17] | yes  | varies  | yes  | yes  | user definable
APL | 1  | ?  | 0 or 1[18] | checked  | yes  | yes  | yes
AWK | 1  | yes, implicitly  | no  | unchecked  | yes, as delimited string  | yes, rehashed  | no
BASIC | 0  | ?  | no  | checked  | no  | init[15] | ?
C | 0  | no  | no[19] | unchecked  | partially  | init,[15][20] heap[21] | no
Ch | 0  | no  | no  | checked  | yes, also array of array[22] | init,[15][20] heap[21] | yes
C++[16] | 0  | no  | no[19] | unchecked  | yes, also array of array[22] | heap[21] | no
C# | 0  | no  | partial[23] | checked  | yes  | heap[21][24] | yes (LINQ select)
CFML  | 1  | no  | no  | checked  | yes, also array of array[22] | yes  | no
COBOL | 1  | no[25] | no  | checked  | array of array[22][26] | no[27] | some intrinsics
Cobra | 0  | no  | no  | checked  | array of array[22] | heap  | ?
Common Lisp | 0  | ?  | no  | checked[28] | yes  | yes  | yes (map or map-into)
D | 0  | yes[29] | no  | varies[30] | yes  | yes  | ?
F# | 0  | no  | partial[23] | checked  | yes  | heap[21][24] | yes (map)
FreeBASIC | 0  | no  | yes  | checked  | yes  | init,[15] init[31] | ?
Fortran | 1  | yes  | yes  | varies[32] | yes  | yes  | yes
FoxPro | 1  | ?  | no  | checked  | yes  | yes  | ?
Go | 0  | no  | no  | checked  | array of array[22] | no[33] | no
Hack | 0  | yes  | yes  | checked  | yes  | yes  | yes
Haskell | 0  | yes[34] | yes  | checked  | yes, also array of array[22] | init[15] | ?
IDL | 0  | ?  | no  | checked  | yes  | yes  | yes
ISLISP | 0  | ?  | no  | checked  | yes  | init[15] | yes (map or map-into)
J | 0  | ?  | no  | checked  | yes  | yes  | yes
Java[16] | 0  | no  | no  | checked  | array of array[22] | init[15] | ?
JavaScript | 0  | no  | no  | checked[35] | array of array[22] | yes  | yes
Julia | 1  | yes  | yes  | checked (can be skipped locally; or globally by user) | yes, also array of array  | yes  | yes
Lingo | 1  | ?  | ?  | unchecked  | yes  | yes  | yes
Lua | 1  | ?  | partial[36] | checked  | array of array[22] | yes  | ?
Mathematica | 1  | no  | no  | checked  | yes  | yes  | yes
MATLAB | 1  | ?  | no  | checked  | yes[37] | yes  | yes
Nim | 0  | yes[2] | yes  | optional[38] | array of array[22] | yes  | yes[39]
Oberon | 0  | ?  | no  | checked  | yes  | no  | ?
Oberon-2 | 0  | ?  | no  | checked  | yes  | yes  | ?
Objective-C[16] | 0  | no  | no  | checked  | array of array[22] | yes  | no
OCaml | 0  | no  | no  | checked by default  | array of array[22] | init[15] | ?
Pascal, Object Pascal | index type[14] | yes  | yes  | varies[40] | yes  | varies[41] | some
Perl | 0  | no  | yes (`$[`)  | checked[35] | array of array[22] | yes  | no[42]
Raku | 0  | no  | no  | checked[35] | yes  | yes  | yes
PHP | 0  | yes[43] | yes[43] | checked[43] | yes  | yes  | yes
PL/I  | 1  | yes  | yes  | optional  | yes  | no  | yes[44]
Python | 0  | no  | no  | checked  | array of array[22] | yes  | no[45]
RPG | 1  | no  | no  | ?  | no  | no  | ?
R | 1  | ?  | no  | unchecked  | yes, also array of array  | yes  | yes
Ring | 1  | ?  | partial[36] | checked  | array of array[22] | yes  | ?
Ruby | 0  | no  | no  | checked[35] | array of array[22] | yes  | ?
Rust | 0  | no  | no  | checked  | array of array[22] | no  | ?
Sass | 1  | no  | no  | checked  | array of array[22] | init[30] | ?
S-Lang  | 0  | ?  | no  | checked  | yes  | yes  | yes
Scala | 0  | no  | no  | checked  | array of array[22] | init[15] | yes (map)
Scheme | 0  | ?  | no  | checked  | array of array[22] | init[15] | yes (map)
Smalltalk[16] | 1  | ?  | no  | checked  | array of array[22] | yes[46] | ?
Swift | 0  | no  | no  | checked  | array of array[22] | yes  | ?
Visual Basic | 0, 1, or index type[47] | no  | yes  | checked  | yes  | yes  | ?
Visual Basic .NET | 0 or index type[47] | no  | partial[23] | checked  | yes  | yes  | yes (LINQ select)
Wolfram Language | 1  | no  | no  | checked  | yes  | yes  | yes
Windows PowerShell  | 0  | no  | no  | checked  | yes  | heap  | ?
Xojo | 0  | no  | no  | checked  | yes  | yes  | no
XPath/XQuery | 1  | no  | no  | checked  | array of array[3][22] | yes  | yes

## Vectorized array operations

Some compiled languages such as Ada and Fortran, and some scripting languages such as IDL, MATLAB, and S-Lang, have native support for vectorized operations on arrays. For example, to perform an element by element sum of two arrays, a and b to produce a third c, it is only necessary to write

c = a + b

In addition to support for vectorized arithmetic and relational operations, these languages also vectorize common mathematical functions such as sine. For example, if x is an array, then

y = sin (x)

will result in an array y whose elements are sine of the corresponding elements of the array x.

Vectorized index operations are also supported. As an example,

even = x(2::2);
odd = x(::2);

is how one would use Fortran to create arrays from the even and odd entries of an array. Another common use of vectorized indices is a filtering operation. Consider a clipping operation of a sine wave where amplitudes larger than 0.5 are to be set to 0.5. Using S-Lang, this can be done by

y = sin(x);
y[where(abs(y)>0.5)] = 0.5;

### Mathematical matrix operations

Language/
Library  | Create  | Determinant | Transpose | Element  | Column  | Row  | Eigenvalues

|
|
|
|
|
|
|

APL | `m←dims⍴x11 x12 ...` | `-.×m` | `⍉m` | `m[i;j]` or `i j⌷m` | `m[;j]` or `j⌷[2]m` or
`j⌷⍤1⊢m` or `j⌷⍉m` | `m[i;]` or `i⌷m` | `⌹⍠1⊢m`
Fortran | `m = RESHAPE([x11, x12, ...], SHAPE(m))` |  | `TRANSPOSE(m)` | `m(i,j)` | `m(:,j)` | `m(i,:)` |
Ch[48] | `m = {...`}  | `determinant(m)` | `transpose(m)` | `m[i-1][j-1]` | `shape(m,0)` | `shape(m,1)` | `eigen(output, m, NULL)`
Mathematica /
Wolfram Language | `{{x11, x12, ...}, ...}` | `Det[m]` | `Transpose[m]` | `mi,j` | `m;;,j` | `mi` | `Eigenvalues[m]`
MATLAB /
GNU Octave | `m = [...]` | `det(m)` | `m.'` | `m(i,j)` | `m(:,j)` | `m(i,:)` | `eig(m)`
NumPy | `m = mat(...)` | `linalg.det(m)` | `m.T` | `m[i-1,j-1]` | `m[:,j-1]` | `m[i-1,:]` | `linalg.eigvals(m)`
R | `m <- matrix(...)` or `m <- array(...)` | `det(m)` | `t(m)` | `m[i, j]` | `m[, j]` | `m[i, ]` | `eigen(m)`
S-Lang  | `m = reshape([x11, x12, ...], [new-dims])` |  | `m = transpose(m)` | `m[i,j]` | `m[*,j]` | `m[j,*]` |
SymPy | `m = Matrix(...)` |  | `m.T` | `m[i-1,j-1]` |  |  |

## References

1. ↑ "Programming in Lua : 11.1". https://www.lua.org/pil/11.1.html.
2. ↑ 2.0 2.1 "Nim Tutorial (Part I)". https://nim-lang.org/docs/tut1.html#advanced-types-arrays.
3. ↑ 3.0 3.1 3.2 3.3 3.4 XPath/XQuery has two kinds of arrays. Sequences (1,2,3) which cannot nest and in the XPath/XQuery 3.1 version arrays array { 1,2,3 } or [1,2,3] which can.
4. ↑ 4.0 4.1 4.2 4.3 4.4 4.5 4.6 The index may be a negative number, indicating the corresponding number of places before the end of the array.
5. ↑ "Eiffeldoc : ARRAY". http://smarteiffel.loria.fr/libraries/api/lib.d/storage.d/loadpath.se.d/collection.d/ARRAY/ANY.html.
6. ↑ 6.0 6.1 6.2 6.3 6.4 6.5 Slices for multidimensional arrays are also supported and defined similarly.
7. ↑ 7.0 7.1 7.2 7.3 Slices of the type `first:last:step` are also supported.
8. ↑ 8.0 8.1 8.2 8.3 last or end may be a negative number, indicating to stop at the corresponding number of places before the end of the array.
9. ↑ 9.0 9.1 9.2 More generally, for 1-d arrays Perl and S-Lang allow slices of the form`array[indices]`, where `indices` can be a range such mentioned in footnote 2 or an explicit list of indices, e.g., '`[0,9,3,4]`', or a mix of both, e.g., `A[0:3,7,9,[11:2:-3]]]`.
10. ↑ C# 8.0 proposed feature (as of 29 August 2019[update])
11. ↑ "Ranges - C# 8.0 language proposals". Microsoft. https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-8.0/ranges. Retrieved 29 August 2019.
12. ↑ "Lua 5.3 Reference Manual". https://www.lua.org/manual/5.3/manual.html#pdf-table.move.
13. ↑ The index type can be a freely chosen integer type, enumerated type, or character type. For arrays with non-compact index types see: Associative array
14. ↑ 14.0 14.1 The default base index is the lowest value of the index type used
15. ↑ 15.00 15.01 15.02 15.03 15.04 15.05 15.06 15.07 15.08 15.09 15.10 Size can only be chosen on initialization after which it is fixed.
16. ↑ 16.0 16.1 16.2 16.3 16.4 This list is strictly comparing language features. In every language (even assembler) it is possible to provide improved array handling via add on libraries. This language has improved array handling as part of its standard library
17. ↑ ALGOL 68 arrays must be subscripted (and sliced) by type INT. However a hash function could be used to convert other types to INT. e.g. name[hash("string")]
18. ↑ The indexing base can be 0 or 1 as per the System Variable ⎕IO. This value may apply to the whole "workspace", or be localized to a user-defined function or a single primitive function by use of the Variant operator (⍠).
19. ↑ 19.0 19.1 Because C does not bound-check indices, a pointer to the interior of any array can be defined that will symbolically act as a pseudo-array that accommodates negative indices or any integer index origin.
20. ↑ 20.0 20.1 C99 allows for variable size arrays; however there is almost no compiler available to support this new feature
21. ↑ 21.0 21.1 21.2 21.3 21.4 Size can only be chosen on initialization when memory is allocated on the heap, as distinguished from when it is allocated on the stack. This note need not be made for a language that always allocates arrays on the heap.
22. ↑ 22.00 22.01 22.02 22.03 22.04 22.05 22.06 22.07 22.08 22.09 22.10 22.11 22.12 22.13 22.14 22.15 22.16 22.17 22.18 22.19 22.20 22.21 22.22 22.23 Allows arrays of arrays which can be used to emulate most—but not all—aspects multi-dimensional arrays
23. ↑ 23.0 23.1 23.2 The base can be changed when initializing with System.Array.CreateInstance (which returns System.Array), but not when using the language syntax. Arrays with non-zero base indices are not the same type as those with zero base indices and cannot be manipulated using language syntax (the GetValue and SetValue methods must be used instead) or downcast to a specific type (T[] in C#, or T() in VB.NET), preventing breakage of code assuming base indices of zero.
24. ↑ 24.0 24.1 Allows creating fixed-size arrays in "unsafe" code, allowing enhanced interoperability with other language
25. ↑ COBOL arrays may be indexed with "INDEX" types, distinct from integer types
26. ↑ While COBOL only has arrays-of-arrays, array elements can be accessed with a multi-dimensional-array-like syntax, where the language automatically matches the indexes to the arrays enclosing the item being referenced
27. ↑ COBOL provides a way to specify that the usable size of an array is variable, but this can never be greater than the declared maximum size, which is also the allocated size
28. ↑ Most Common Lisp implementations allow checking to be selectively disabled
29. ↑ Associative Arrays - D Programming Language
30. ↑ 30.0 30.1 Behaviour can be tuned via compiler switches. As in DMD 1.0 bounds are checked in debug mode and unchecked in release mode for efficiency
31. ↑ FreeBASIC supports both variable array lengths and fixed length arrays. Arrays declared with no index range are created as variable-length arrays, while arrays with a declared range are created as fixed-length arrays
32. ↑ Almost all Fortran implementations offer bounds checking options via compiler switches. However by default, bounds checking is usually turned off for efficiency
33. ↑ While Golang's Array type is not dynamically sized, the data type Slice is dynamically-sized and is much more common in use than arrays.
34. ↑ Haskell arrays (Data.Array) allow using any type which is an instance of Ix as index type. So a custom type can be defined and used as an index type as long as it instances Ix. Also, tuples of Ix types are also Ix types; this is commonly used to implement multi-dimensional arrays
35. ↑ 35.0 35.1 35.2 35.3 In these languages, one can access or write to an array index greater than or equal to the length of the array, and the array will implicitly grow to that size. This may appear at first as if the bounds are not checked; however, the bounds are checked in order to decide to grow the array, and you do not have unsafe memory access like you do in C.
36. ↑ 36.0 36.1 By specifying a base index, arrays at an arbitrary base can be created. However, by default, Lua's length operator does not consider the base index of the array when calculating the length. This behavior can be changed via metamethods.
37. ↑ At least 2 dimensions (scalar numbers are 1×1 arrays, vectors are 1×n or n×1 arrays).
38. ↑ "Nim Compiler User Guide". https://nim-lang.org/docs/nimc.html.
39. ↑ "Vectorization - R-style logical vector operation in Nim". https://stackoverflow.com/questions/53084192/r-style-logical-vector-operation-in-nim.
40. ↑ Many implementations (Turbo Pascal, Object Pascal (Delphi), FreePascal) allow the behaviour to be changed by compiler switches and in-line directives
41. ↑ Varies by implementation. Newer implementations (FreePascal, Object Pascal (Delphi)) allow heap-based dynamic arrays.
42. ↑ Standard Perl array data types do not support vectorized operations as defined here. However, the Perl Data Language extension adds array objects with this ability.
43. ↑ 43.0 43.1 43.2 PHP's "arrays" are associative arrays. You can use integers and strings as the keys (indexes); floats can also be used as the key but are truncated to integers. There is not really any "base index" or "bounds"
44. ↑ Size can be chosen when the array is declared, or when it is allocated, after which it is fixed.
45. ↑ The standard Python array type, `list`, does not support vectorized operations as defined here. However, the numpy extension adds array objects with this ability
46. ↑ The class Array is fixed-size, but OrderedCollection is dynamic
47. ↑ 47.0 47.1 Microsoft QBASIC, QuickBASIC, Visual Basic, and VBA all had/have the ability to specify Option Base 1, which caused all arrays in the module to default starting at 1 instead of 0. Support for Option Base was phased out in Visual Basic .NET. In various Microsoft BASIC implementations, arrays can be DIMensioned using to in order to specify the minimum and maximum index values (e.g. DIM MyArray(2 to 50) AS STRING would have the first index at 2 instead of the default).
48. ↑ Ch numerical features

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Comparison of programming languages (array). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Comparison_of_programming_languages_(array)&oldid=273144"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template