Comparison of programming languages (array) - Informatika Komputer

Programming language comparisons
General comparison Basic syntax Basic instructions Arrays Associative arrays String operations String functions List comprehension Object-oriented programming Object-oriented constructors Database access
Evaluation strategy Daftar/Tabel -- "Hello World" programs
ALGOL 58's influence on ALGOL 60 ALGOL 60: Comparisons with other languages Perbandingan -- ALGOL 68 and C++ ALGOL 68: Comparisons with other languages Compatibility of C and C++ Perbandingan -- Pascal and Borland Delphi Perbandingan -- Object Pascal and C Perbandingan -- Pascal and C Perbandingan -- Java and C++ Perbandingan -- C# and Java Perbandingan -- C# and Visual Basic .NET Perbandingan -- Visual Basic and Visual Basic .NET
Web application frameworks Perbandingan -- the Java and .NET platforms

1 Syntax
2 Array system cross-reference list
3 Vectorized array operations
- 3.1 Mathematical matrices management
4 References

Syntax

Array dimensions

The following list contains Syntax examples on how to determine the dimensions (index of the first element, the last element and/or the size in elements):

Size	First	Last	Languages
name'Length	name'First	name'Last	Ada
UPB name - LWB name+1 or 2 UPB name - 2 LWB name+1 etc.	LWB name or 2 LWB name etc.	UPB name or 2 UPB name etc.	ALGOL 68
name.Length	name.GetLowerBound(dimension)	name.GetUpperBound(dimension)	C#, Visual Basic .NET, Windows PowerShell, F#
max(shape(name))	0	max(shape(name))-1	Ch
(length name)	0	(1- (length name))	Common Lisp
SIZE(name)	LBOUND(name)	UBOUND(name)	Fortran
len(name)	0	len(name) - 1	Go
rangeSize (bounds name)	fst (bounds name)	snd (bounds name)	Haskell
(length name)	0	(1- (length name))	ISLISP
name.length	0	name.length - 1	Java, JavaScript, D, Scala
#name	1	#name	Lua
Length[name]	1 or First[name]	-1 or Last[name]	Mathematica
length(name)	1	end	MATLAB, GNU Octave
Length(name)	name[0]	name[Length(name)-1]	Object Pascal
[name count]	0	[name count] - 1	Objective-C (`NSArray *` only)
Array.length name	0	Array.length name - 1	OCaml
scalar(@name)	$[	$#name	Perl
@name.elems	0	@name.end	Perl 6
count($name)	0	count($name) - 1	PHP
len(name)	0	-1 or len(name) - 1	Python
name.size	0 (name.first will also refer to this element)	-1 or name.size - 1 (name.last will also refer to this element)	Ruby
length(name)	0	-1 or length(name)-1	S-Lang
(vector-length vector)	0	(- (vector-length vector) 1)	Scheme
name size	1 (name first will also refer to this element)	name size (name last will also refer to this element)	Smalltalk
UBound(name)-LBound(name)+1	LBound(name)	UBound(name)	Visual Basic

Indexing

The following list contains Syntax examples on how a single element of an array can be accessed.

Format	Languages
name[index] or name[index₁, index₂] etc.	ALGOL 68, Pascal, Object Pascal, C#, S-Lang¹
name[index]	C, Ch, C++, D, Go, Java, ActionScript 3.0, JavaScript, Perl¹, PHP, Python¹, Ruby¹, Lua
$name[index]	Perl¹, PHP, Windows PowerShell¹
@name[index]	Perl 6
name(index)	Ada, Fortran, BASIC, Visual Basic, Visual Basic .NET, RPG, MATLAB, Scala
name.(index)	OCaml
name.[index]	F#
name ! index	Haskell
(vector-ref name index)	Scheme
(aref name index)	Common Lisp
(elt name index)	ISLISP
name [[index]]	Mathematica¹
name at:index	Smalltalk
[name objectAtIndex:index]	Objective-C (`NSArray *` only)

The index may be a negative number, indicating the corresponding number of places before the end of the array.

Slicing

The following list contains Syntax examples on 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)

Format	Languages
name[first:last]	ALGOL 68¹
name[first:end:len]	Python^2,4, Go
name[first..last]	Pascal, Object Pascal, Delphi, D
$name[first..last]	Windows PowerShell
@name[first..last]	Perl³
name[first..last] name[first...end] name[first, len]	Ruby⁴
name(first..last)	Ada¹
name(first:last)	Fortran^1,2, MATLAB^1,3
name[[first;last]]	Mathematica^1,2,4
name[[first:last]]	S-Lang^1,2,3
name.[first..last]	F#
name.slice(first, last)	JavaScript, Scala
array_slice(name, first, len)	PHP⁴
(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)

Slices for multidimensional arrays are also supported and defined similarly.
Slices of the type first:last:step are also supported.
More generally, for 1-d arrays Perl and S-Lang permit 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]', as well as a combination of the two, e.g., A[[[0:3]],7,9,[11:2:-3]]].
last or end may be a negative number, indicating to stop at the corresponding number of places before the end of the array.

Array system cross-reference list

Programming language	Default base index	Specifiable index type¹⁶	Specifiable base index	Bound check	Multidimensional	Dynamically-sized	Vectorized operations
Ada	index type¹⁷	yes	yes	checked	yes	init¹	some, others definable⁵
ALGOL 68	1	no²⁵	yes	varies	yes	yes	user definable
APL	?	?	0 or 1⁷	checked	yes	init¹	yes
BASIC	0	?	no	checked	no	init¹	?
C	0	no	no²⁶	unchecked	yes, also array of array²	init^1,4, heap³	no
Ch	0	no	no	checked	yes, also array of array²	init^1,4, heap³	yes
C++⁵	0	no	no²⁶	unchecked	yes, also array of array²	heap³	no
C#	0	no	no	checked	yes	heap^3,9	yes (LINQ select)
COBOL	1	no²⁷	no	checked	array of array² ²⁸	no¹⁴	some intrinsics
Common Lisp	0	?	no	checked¹⁵	yes	yes	yes (map or map-into)
D	0	?	no	varies¹¹	yes	yes	?
F#	0	no	no	checked	yes	heap^3,9	yes (map)
FreeBASIC	0	no	yes	checked	yes	init¹,init²¹	?
Fortran	1	yes	yes	varies¹²	yes	yes	yes
FoxPro	1	?	no	checked	yes	yes	?
Go	0	no	no	checked	array of array²	no	no
Haskell	none (specified on init)	yes²⁴	yes	checked	yes, also array of array²	init¹	?
IDL	0	?	no	checked	yes	yes	yes
ISLISP	0	?	no	checked	yes	init¹	yes (map or map-into)
Java⁵	0	no	no	checked	array of array²	init¹	?
JavaScript	0	no	no	checked²²	array of array²	yes	yes
Lua	1	?	partial²⁰	checked	array of array²	yes	?
Mathematica	1	no	no	checked	yes	yes	yes
MATLAB	1	?	no	checked	yes⁸	yes	yes
Oberon	0	?	no	checked	yes	no	?
Oberon-2	0	?	no	checked	yes	yes	?
Objective-C⁵	0	no	no	checked	array of array²	yes	no
OCaml	0	no	no	checked by default	array of array²	init¹	?
Pascal, Object Pascal	index type¹⁷	yes	yes	varies¹³	yes	varies¹⁰	some
Perl	0	no	yes (`$[`)	checked²²	array of array²	yes	no¹⁸
Perl 6	0	no	no	checked²²	yes	yes	yes
PHP	0	yes²³	yes²³	checked²³	yes	yes	yes
PL/I	1	?	yes	checked	yes	no	?
Python	0	no	no	checked	array of array²	yes	no¹⁹
RPG	1	no	no	?	no	no	?
Ruby	0	no	no	checked²²	array of array²	yes	?
S-Lang	0	?	no	checked	yes	yes	yes
Scala	0	no	no	checked	array of array²	init¹	yes (map)
Scheme	0	?	no	checked	array of array²	init¹	yes (map)
Smalltalk⁵	1	?	no	checked	array of array²	yes⁶	?
Visual Basic	0	no	yes	checked	yes	yes	?
Visual Basic .NET	0	no	no	checked	yes	yes	yes (LINQ select)
Windows PowerShell	0	no	no	checked	yes	heap	?
XPath	1	no	no	checked	no	yes	yes
Programming language	Default base index	Specifiable index type¹⁶	Specifiable base index	Bound check	Multidimensional	Dynamically-sized	Vectorized operations

Size can only be chosen on initialization after which it is fixed.
Allows arrays of arrays which can be used to emulate most—but not all—aspects multi-dimensional arrays.
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.
C99 allows for variable size arrays; however there is almost no compiler available to support this new feature.
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.
The class Array is fixed-size, but OrderedCollection is dynamic.
The indexing base can be 0 or 1, but is set for a whole "workspace".
At least 2 dimensions (scalar numbers are 1×1 arrays, vectors are 1×n or n×1 arrays).
Allows creation of fixed-size arrays in "unsafe" code, allowing for enhanced interoperability with other languages
Varies by implementation. Newer implementations (FreePascal, Object Pascal (Delphi)) permit heap-based dynamic arrays.
Behaviour can be tuned using compiler switches. As in DMD 1.0 bounds are checked in debug mode and unchecked in release mode for efficiency reasons.
Almost all Fortran implementations offer bounds checking options via compiler switches. However by default, bounds checking is usually turned off for efficiency reasons.
Many implementations (Turbo Pascal, Object Pascal (Delphi), FreePascal) allow the behaviour to be changed by compiler switches and in-line directives.
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.
Most Common Lisp implementations allow checking to be selectively disabled.
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.
The default base index is the lowest value of the index type used.
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.
The standard Python array type, list, does not support vectorized operations as defined here. However, the numpy extension adds array objects with this ability.
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.
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.
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.
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".
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.
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")]
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.
COBOL arrays may be indexed with "INDEX" types, distinct from integer types.
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.

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 may accomplished by

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

Mathematical matrices management

Language/Library	Create	Determinant	Transpose	Element	Column	Row	Eigenvalues
Fortran	m=RESHAPE([x11,x12,...], SHAPE(m))		TRANSPOSE(m)	m(i,j)	m(:,j)	m(i,:)
Ch ^[1]	m = {...}	determinant( m )	transpose( m )	m[i-1][j-1]	shape(m,0)	shape(m,1)	eigen(output, m, NULL)
Mathematica	m={{x11,x12,...},...}	Det[m]	Transpose[m]	m[[i,j]]	m[[; , j]]	m[[i]]	Eigenvalues[m]
MATLAB / GNU Octave	m = [...]	det( m )	m'	m( i, j )	m( :, j )	m( i, : )	eig( m )
NumPy	m=mat(...)		m.T	m[i-1,j-1]	m[:,i-1]	m[i-1,:]
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

^ Ch numerical features

Perbandingan -- programming languages (array)

Contents