Comparison of programming languages (array)

Last updated

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

Contents

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.

LanguagesSizeFirstLast
Ada name'Lengthname'Firstname'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 length1asorti
C#, Visual Basic .NET, Windows PowerShell, F# name.Lengthname.GetLowerBound(dimension)name.GetUpperBound(dimension)
CFML arrayLen(name)
name.len()		1name.len()
Ch max(shape(name))0max(shape(name))-1
Common Lisp (length name)0(1- (length name))
D name.length0name.length-1
$-1
Fortran size(name)lbound(name)ubound(name)
Go len(name)0len(name) - 1
Haskell rangeSize (bounds name)fst (bounds name)snd (bounds name)
ISLISP (length name)0(1- (length name))
Icon *name1*name
Cobra, D, Haxe, Java, JavaScript, Scala name.length0name.length - 1
J #name0<:@#name
JavaScript (ES2022)name.length0
name.at(0) [1] 		name.length - 1
name.at(-1) [1]
Julia length(name)
size(name)		begin
first.(axes(name))		end
last.(axes(name))
Lingo count(name)1getLast(name)
LiveCode length(name)1
first		-1
last
Lua #name1 by convention; any integer [2] #name
Mathematica Length[name]1
First[name]		-1
Last[name]
MATLAB, GNU Octave length(name)1end
Nim name.lenname.low [3] name.high
Oberon LEN(name)0LEN(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 name0Array.length name - 1
Perl scalar(@name)$[$#name
PHP count(name)0count(name) - 1
PL/I dim(name[,dim])lbound(name[,dim])hbound(name[,dim])
Python len(name)0-1
len(name) - 1
R length(name)1length(name)
Raku @name.elems0@name.end
Red length? namename/1
first name		last name
Ruby name.size0
name.first		-1
name.size - 1
name.last
Rust name.len()0name.len() - 1
S-Lang length(name)0-1
length(name)-1
Scheme (vector-length vector)0(- (vector-length vector) 1)
Smalltalk name size1
name first		name size
name last
Swift name.count0name.count - 1
Unicon *name1*name
Visual Basic UBound(name)-LBound(name)+1LBound(name)UBound(name)
Wolfram Language Length[name]1
First[name]		-1
Last[name]
Xojo UBound(name)0UBound(name)
XPath/XQuery count($name)1count($name)
last()
array:size(name) [4]

Indexing

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

FormatLanguages
name[index] or name[index1, index2] etc. ALGOL 58, ALGOL 60, ALGOL 68, AWK, Julia, Modula, Pascal, Object Pascal, C#, S-Lang [5] 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, [5] PHP, Python, [5] R, Ruby, [5] Rust, Swift
$name[index] Perl, [5] Windows PowerShell, [5] XPath/XQuery [4]
@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 [4]
name.(index) OCaml
name.[index] F#, OCaml
name/index Red
name ! index Haskell
$name ? index XPath/XQuery [4]
(vector-ref name index) Scheme
(aref name index) Common Lisp
(elt name index) ISLISP
name[[index]] Mathematica, [5] Wolfram Language
name at:index Smalltalk
[name objectAtIndex:index] Objective-C (NSArray * only)
index{name J
name.item(index) or name @ index [6] Eiffel

Slicing

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

In the following table:

FormatLanguages
name[first:last] ALGOL 68, [7] Julia, Icon, Unicon
name[first+(⍳len)-⎕IO] APL
name[first:end:step] Python [8] [9]
name[first:end] Go
name[first..last] Pascal, Object Pascal, Delphi, Nim
$name[first..last] Windows PowerShell
@name[first..last] Perl [10]
name[first..last]
name[first...end]
name[first, len]		 Ruby [9]
copy/part skip name first len Red
name(first..last) Ada [7]
name(first:last) Fortran, [7] [8] GNU Octave, MATLAB [7] [10]
name[[first;;last;;step]] Mathematica, [7] [8] [9] Wolfram Language
name[[first:last]] S-Lang [7] [8] [10]
name.[first..step..last] F#
name.slice(first, end) Haxe, JavaScript, Scala
name.slice(first, len) CFML
array_slice(name, first, len) PHP [9]
(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# [11] [12]
name[first..end]
name[first..=last]		 Rust
name[first:end] Cobra
table.move(name, first, last, 1, {}) Lua [13]

Array system cross-reference list

Language Default
base index 		Specifiable
index type [14] 		Specifiable
base index		 Bound check Multidimensional Dynamically-sized Vectorized operations
Ada index type [15] yesyescheckedyesinit [16] some, others definable [17]
ALGOL 68 1no [18] yesvariesyesyesuser definable
APL 1 ?0 or 1 [19] checkedyesyesyes
AWK 1yes, implicitlynouncheckedyes, as delimited stringyes, rehashedno
BASIC 0 ?nocheckednoinit [16]  ?
C 0nono [20] uncheckedpartiallyinit, [16] [21] heap [22] no
Ch 0nonocheckedyes, also array of array [23] init, [16] [21] heap [22] yes
C++ [17] 0nono [20] uncheckedyes, also array of array [23] heap [22] no
C# 0nopartial [24] checkedyesheap [22] [25] yes (LINQ select)
CFML 1nonocheckedyes, also array of array [23] yesno
COBOL 1no [26] nocheckedarray of array [23] [27] no [28] some intrinsics
Cobra 0nonocheckedarray of array [23] heap ?
Common Lisp 0 ?nochecked [29] yesyesyes (map or map-into)
D 0yes [30] novaries [31] yesyes ?
F# 0nopartial [24] checkedyesheap [22] [25] yes (map)
FreeBASIC 0noyescheckedyesinit, [16] init [32]  ?
Fortran 1yesyesvaries [33] yesyesyes
FoxPro 1 ?nocheckedyesyes ?
Go 0nonocheckedarray of array [23] no [34] no
Hack 0yesyescheckedyesyesyes
Haskell 0yes [35] yescheckedyes, also array of array [23] init [16]  ?
IDL 0 ?nocheckedyesyesyes
ISLISP 0 ?nocheckedyesinit [16] yes (map or map-into)
J 0 ?nocheckedyesyesyes
Java [17] 0nonocheckedarray of array [23] init [16]  ?
JavaScript 0nonochecked [36] array of array [23] yesyes
Julia 1yesyeschecked (can be skipped locally; or globally by user)yes, also array of arrayyesyes
Lingo 1 ? ?uncheckedyesyesyes
Lua 1 ?partial [37] checkedarray of array [23] yes ?
Mathematica 1nonocheckedyesyesyes
MATLAB 1 ?nocheckedyes [38] yesyes
Nim 0yes [3] yesoptional [39] array of array [23] yesyes [40]
Oberon 0 ?nocheckedyesno ?
Oberon-2 0 ?nocheckedyesyes ?
Objective-C [17] 0nonocheckedarray of array [23] yesno
OCaml 0nonochecked by defaultarray of array [23] init [16]  ?
Pascal, Object Pascal index type [15] yesyesvaries [41] yesvaries [42] some
Perl 0noyes ($[)checked [36] array of array [23] yesno [43]
Raku 0nonochecked [36] yesyesyes
PHP 0yes [44] yes [44] checked [44] yesyesyes
PL/I 1yesyesoptionalyesnoyes [45]
Python 0nonocheckedarray of array [23] yesno [46]
RPG 1nono ?nono ?
R 1 ?nouncheckedyes, also array of arrayyesyes
Ring 1 ?partial [37] checkedarray of array [23] yes ?
Ruby 0nonochecked [36] array of array [23] yes ?
Rust 0nonocheckedarray of array [23] no ?
Sass 1nonocheckedarray of array [23] init [31]  ?
S-Lang 0 ?nocheckedyesyesyes
Scala 0nonocheckedarray of array [23] init [16] yes (map)
Scheme 0 ?nocheckedarray of array [23] init [16] yes (map)
Smalltalk [17] 1 ?nocheckedarray of array [23] yes [47]  ?
Swift 0nonocheckedarray of array [23] yes ?
Visual Basic 0, 1, or index type [48] noyescheckedyesyes ?
Visual Basic .NET 0 or index type [48] nopartial [24] checkedyesyesyes (LINQ select)
Wolfram Language 1nonocheckedyesyesyes
Windows PowerShell 0nonocheckedyesheap ?
Xojo 0nonocheckedyesyesno
XPath/XQuery 1nonocheckedarray of array [4] [23] yesyes

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 ElementColumnRow Eigenvalues
APL m←dims⍴x11x12...-.×m⍉mm[i;j] or ij⌷mm[;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 [49] 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]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(...)linalg.det(m)m.Tm[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.det()m.Tm[i-1,j-1]m.col(j-1)m.row(i-1)m.eigenvals()

Related Research Articles

In computer science, an array is a data structure consisting of a collection of elements, of same memory size, each identified by at least one array index or key. An array is stored such that the position of each element can be computed from its index tuple by a mathematical formula. The simplest type of data structure is a linear array, also called one-dimensional array.

C is a general-purpose computer programming language. It was created in the 1970s by Dennis Ritchie, and remains very widely used and influential. By design, C's features cleanly reflect the capabilities of the targeted CPUs. It has found lasting use in operating systems, device drivers, and protocol stacks, but its use in application software has been decreasing. C is commonly used on computer architectures that range from the largest supercomputers to the smallest microcontrollers and embedded systems.

<span class="mw-page-title-main">Data structure</span> Particular way of storing and organizing data in a computer

In computer science, a data structure is a data organization, management, and storage format that is usually chosen for efficient access to data. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data, i.e., it is an algebraic structure about data.

Euphoria is a programming language created by Robert Craig of Rapid Deployment Software in Toronto, Ontario, Canada. Initially developed on the Atari ST, the first commercial release was for MS-DOS as proprietary software. In 2006, with the release of version 3, Euphoria became open-source software. The openEuphoria Group continues to administer and develop the project. In December 2010, the openEuphoria Group released version 4 of openEuphoria along with a new identity and mascot for the project. OpenEuphoria is currently available for Windows, Linux, macOS and three flavors of *BSD.

Pascal is an imperative and procedural programming language, designed by Niklaus Wirth as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named after French mathematician, philosopher and physicist Blaise Pascal.

<span class="mw-page-title-main">Lua (programming language)</span> Lightweight programming language

Lua is a lightweight, high-level, multi-paradigm programming language designed primarily for embedded use in applications. Lua is cross-platform, since the interpreter of compiled bytecode is written in ANSI C, and Lua has a relatively simple C API to embed it into applications.

Generic programming is a style of computer programming in which algorithms are written in terms of data types to-be-specified-later that are then instantiated when needed for specific types provided as parameters. This approach, pioneered by the ML programming language in 1973, permits writing common functions or types that differ only in the set of types on which they operate when used, thus reducing duplicate code.

In mathematics and computer programming, index notation is used to specify the elements of an array of numbers. The formalism of how indices are used varies according to the subject. In particular, there are different methods for referring to the elements of a list, a vector, or a matrix, depending on whether one is writing a formal mathematical paper for publication, or when one is writing a computer program.

<span class="mw-page-title-main">C syntax</span> Set of rules defining correctly structured programs

The syntax of the C programming language is the set of rules governing writing of software in C. It is designed to allow for programs that are extremely terse, have a close relationship with the resulting object code, and yet provide relatively high-level data abstraction. C was the first widely successful high-level language for portable operating-system development.

<span class="mw-page-title-main">Pointer (computer programming)</span> Object which stores memory addresses in a computer program

In computer science, a pointer is an object in many programming languages that stores a memory address. This can be that of another value located in computer memory, or in some cases, that of memory-mapped computer hardware. A pointer references a location in memory, and obtaining the value stored at that location is known as dereferencing the pointer. As an analogy, a page number in a book's index could be considered a pointer to the corresponding page; dereferencing such a pointer would be done by flipping to the page with the given page number and reading the text found on that page. The actual format and content of a pointer variable is dependent on the underlying computer architecture.

In computer science, a record is a basic data structure. Records in a database or spreadsheet are usually called "rows".

<span class="mw-page-title-main">Foreach loop</span> Control flow statement for traversing items in a collection

In computer programming, foreach loop is a control flow statement for traversing items in a collection. foreach is usually used in place of a standard for loop statement. Unlike other for loop constructs, however, foreach loops usually maintain no explicit counter: they essentially say "do this to everything in this set", rather than "do this x times". This avoids potential off-by-one errors and makes code simpler to read. In object-oriented languages, an iterator, even if implicit, is often used as the means of traversal.

In computer programming, array slicing is an operation that extracts a subset of elements from an array and packages them as another array, possibly in a different dimension from the original.

A bit array is an array data structure that compactly stores bits. It can be used to implement a simple set data structure. A bit array is effective at exploiting bit-level parallelism in hardware to perform operations quickly. A typical bit array stores kw bits, where w is the number of bits in the unit of storage, such as a byte or word, and k is some nonnegative integer. If w does not divide the number of bits to be stored, some space is wasted due to internal fragmentation.

The computer programming languages C and Pascal have similar times of origin, influences, and purposes. Both were used to design their own compilers early in their lifetimes. The original Pascal definition appeared in 1969 and a first compiler in 1970. The first version of C appeared in 1972.

S-algol is a computer programming language derivative of ALGOL 60 developed at the University of St Andrews in 1979 by Ron Morrison and Tony Davie. The language is a modification of ALGOL to contain orthogonal data types that Morrison created for his PhD thesis. Morrison would go on to become professor at the university and head of the department of computer science. The S-algol language was used for teaching at the university at an undergraduate level until 1999. It was also the language taught for several years in the 1980s at a local school in St. Andrews, Madras College. The computer science text Recursive Descent Compiling describes a recursive descent compiler for S-algol, implemented in S-algol.

In computer programming, an enumerated type is a data type consisting of a set of named values called elements, members, enumeral, or enumerators of the type. The enumerator names are usually identifiers that behave as constants in the language. An enumerated type can be seen as a degenerate tagged union of unit type. A variable that has been declared as having an enumerated type can be assigned any of the enumerators as a value. In other words, an enumerated type has values that are different from each other, and that can be compared and assigned, but are not specified by the programmer as having any particular concrete representation in the computer's memory; compilers and interpreters can represent them arbitrarily.

In computer programming, a variable-length array (VLA), also called variable-sized or runtime-sized, is an array data structure whose length is determined at run time . In C, the VLA is said to have a variably modified type that depends on a value.

This article compares a large number of programming languages by tabulating their data types, their expression, statement, and declaration syntax, and some common operating-system interfaces.

In computer science, array is a data type that represents a collection of elements, each selected by one or more indices that can be computed at run time during program execution. Such a collection is usually called an array variable or array value. By analogy with the mathematical concepts vector and matrix, array types with one and two indices are often called vector type and matrix type, respectively. More generally, a multidimensional array type can be called a tensor type, by analogy with the physical concept, tensor.

References

  1. 1 2 "ECMAScript® 2025 Language Specification".
  2. ↑ "Programming in Lua : 11.1".
  3. 1 2 "Nim Tutorial (Part I)".
  4. 1 2 3 4 5 XPath/XQuery has two kinds of arrays. Sequences(1,2,3) which cannot nest and in the XPath/XQuery 3.1 version arraysarray { 1,2,3 } or [1,2,3] which can.
  5. 1 2 3 4 5 6 7 The index may be a negative number, indicating the corresponding number of places before the end of the array.
  6. ↑ "Eiffeldoc : ARRAY".
  7. 1 2 3 4 5 6 Slices for multidimensional arrays are also supported and defined similarly.
  8. 1 2 3 4 Slices of the type first:last:step are also supported.
  9. 1 2 3 4 last or end may be a negative number, indicating to stop at the corresponding number of places before the end of the array.
  10. 1 2 3 More generally, for 1-d arrays Perl and S-Lang allow slices of the formarray[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]]].
  11. ↑ C# 8.0 proposed feature (as of 29 August 2019)
  12. ↑ "Ranges - C# 8.0 language proposals". Microsoft Docs. Microsoft. Retrieved 29 August 2019.
  13. ↑ "Lua 5.3 Reference Manual". www.lua.org. Retrieved 2022-04-02.
  14. ↑ 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
  15. 1 2 The default base index is the lowest value of the index type used
  16. 1 2 3 4 5 6 7 8 9 10 11 Size can only be chosen on initialization after which it is fixed.
  17. 1 2 3 4 5 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
  18. ↑ 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")]
  19. ↑ 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 (⍠).
  20. 1 2 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.
  21. 1 2 C99 allows for variable size arrays; however there is almost no compiler available to support this new feature
  22. 1 2 3 4 5 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.
  23. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 Allows arrays of arrays which can be used to emulate most—but not all—aspects multi-dimensional arrays
  24. 1 2 3 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.
  25. 1 2 Allows creating fixed-size arrays in "unsafe" code, allowing enhanced interoperability with other language
  26. ↑ COBOL arrays may be indexed with "INDEX" types, distinct from integer types
  27. ↑ 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
  28. ↑ 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
  29. ↑ Most Common Lisp implementations allow checking to be selectively disabled
  30. ↑ Associative Arrays - D Programming Language
  31. 1 2 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
  32. ↑ 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
  33. ↑ Almost all Fortran implementations offer bounds checking options via compiler switches. However by default, bounds checking is usually turned off for efficiency
  34. ↑ 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.
  35. ↑ 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
  36. 1 2 3 4 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.
  37. 1 2 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.
  38. ↑ At least 2 dimensions (scalar numbers are 1×1 arrays, vectors are 1×n or n×1 arrays).
  39. ↑ "Nim Compiler User Guide".
  40. ↑ "Vectorization - R-style logical vector operation in Nim".
  41. ↑ Many implementations (Turbo Pascal, Object Pascal (Delphi), FreePascal) allow the behaviour to be changed by compiler switches and in-line directives
  42. ↑ Varies by implementation. Newer implementations (FreePascal, Object Pascal (Delphi)) allow heap-based dynamic arrays.
  43. ↑ 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.
  44. 1 2 3 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"
  45. ↑ Size can be chosen when the array is declared, or when it is allocated, after which it is fixed.
  46. ↑ The standard Python array type, list, does not support vectorized operations as defined here. However, the numpy extension adds array objects with this ability
  47. ↑ The class Array is fixed-size, but OrderedCollection is dynamic
  48. 1 2 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).
  49. ↑ Ch numerical features
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.