Array

Array[f,n]

generates a list of length n, with elements f[i].

Array[f,n,r]

generates a list using the index origin r.

Array[f,n,{a,b}]

generates a list using n values from a to b.

Array[f,{n1,n2,…}]

generates an n1×n2×… array of nested lists, with elements f[i1,i2,…].

Array[f,{n1,n2,…},{r1,r2,…}]

generates a list using the index origins ri (default 1).

Array[f,{n1,n2,…},{{a1,b1},{a2,b2},…}]

generates a list using ni values from ai to bi.

Array[f,dims,origin,h]

uses head h, rather than List, for each level of the array.

Details

Examples

open allclose all

Basic Examples  (4)

Generate a 3×2 array:

Generate a 3×4 array:

Use index origin 0 instead of 1:

Start with indices 0 and 4 instead of 1:

Sample between 0 and 1:

Use ranges {-1/2,1/2} and {0,1}:

Scope  (11)

Array Element Specification  (5)

Create a 3×2 array using an indexed symbol:

Create a 3×2 array using a subscript:

Create a Hilbert matrix:

Use named function slots:

Compare with the built-in function:

Create a constant array:

Use ## to pick up a sequence of indices:

Index Specification  (4)

Create a 1D array:

Create a 1D array, starting the indices at 0:

Create a 3×2 array:

Create a 4×3×2 array with index-dependent origins:

Head Specification  (2)

Use a non-default head for each level of the array:

Use Plus instead of List to combine elements:

Any symbol with attribute Flat would produce the same shape:

Applications  (4)

Totally antisymmetric tensor:

Compare with the built-in LeviCivitaTensor:

Lower-triangular matrix:

Matrix with generic symbolic entries:

Use it to see the effects of some linear algebra functions:

Sample a function uniformly on an interval:

Properties & Relations  (4)

ConstantArray[c,dims] and Array[c&,dims] are equivalent:

When c is a machine number, ConstantArray is much faster for large arrays:

Array[f,dims] can be generated using Table:

Set up the Table limit specifications:

Use Apply to splice them into a Table command:

The result is identical to the array generated using Array:

SparseArray[{i_,j_}->f[i,j],dims] gives a sparse representation of Array[f,dims]:

The results are Equal:

The objects are not identical, but the represented arrays are:

Compute Array in parallel:

Neat Examples  (3)

Array of powers:

Array of GCDs:

Array of arrays:

Wolfram Research (1988), Array, Wolfram Language function, https://reference.wolfram.com/language/ref/Array.html (updated 2012).

Text

Wolfram Research (1988), Array, Wolfram Language function, https://reference.wolfram.com/language/ref/Array.html (updated 2012).

CMS

Wolfram Language. 1988. "Array." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2012. https://reference.wolfram.com/language/ref/Array.html.

APA

Wolfram Language. (1988). Array. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/Array.html

BibTeX

@misc{reference.wolfram_2024_array, author="Wolfram Research", title="{Array}", year="2012", howpublished="\url{https://reference.wolfram.com/language/ref/Array.html}", note=[Accessed: 25-November-2024 ]}

BibLaTeX

@online{reference.wolfram_2024_array, organization={Wolfram Research}, title={Array}, year={2012}, url={https://reference.wolfram.com/language/ref/Array.html}, note=[Accessed: 25-November-2024 ]}