IDL provides a variety of mechanisms to create arrays. IDL arrays can have up to 8 dimensions. Each dimension can have a length between 1 and the maximum integer value (either a 32-bit integer for 32-bit IDL or a 64-bit integer for 64-bit IDL).

## Array Concatenation

Using square brackets, you can combine scalars or arrays into a single array. For example:

`a = [1,2,3,4,5]`
`b = [6,7,8,9,10]`
`c = [a, b]`
`print, c`

IDL prints:

`1       2       3       4       5       6       7       8       9      10`

You can also mix scalars and arrays as long as the arrays are one-dimensional vectors:

`d = [c, 11, a + 11, 17, 18, 19, 20, c + 20]`
`print, d`

IDL prints:

` 1       2       3       4       5       6       7       8       9      10 11      12      13      14      15      16      17      18      19      20 21      22      23      24      25      26      27      28      29      30`

To concatenate second or higher levels, you can nest the brackets. For example, [[1,2,3],[4,5,6]] will create a 3-element by 2-element array with the first row containing 1, 2, 3 and the second row containing 4, 5, 6. The operands must have compatible dimensions: All dimensions must be equal except the dimension that is to be concatenated. For example:

`; For concatenation to work, each row must have the same # of elements (5)`
`kernel1 = [[1,2,4,2,1], [2,4,8,4,2], [1,2,4,2,1]]`
`help, kernel1`
`print, kernel1`

IDL prints:

`KERNEL1          INT       = Array[5, 3]`
` `
`1       2       4       2       1`
`2       4       8       4       2`
`1       2       4       2       1`

Now we can combine this kernel array with another array, along either the first or second dimension. The level of bracket nesting determines which dimension will be concatenated. For example:

`kernel2 = [[-1,0,2,0,-1], [1,2,4,2,1], [-1,0,2,0,-1]]`
`kernelWide = [kernel1, kernel2] ; concatenate along first dimension`
`kernelTall = [[kernel1], [kernel2]] ; concatenate along second dimension`
`help, kernelWide`
`help, kernelTall`

IDL prints:

`KERNELWIDE      INT       = Array[10, 3]`
`KERNELTALL      INT       = Array[5, 6]`

You can nest brackets up to 8 levels deep, which is the maximum number of dimensions for an IDL array. For example:

`IDL> a = fltarr(2,2,2,2,2,2,2,2)`
`IDL> b = a`
`IDL> help, [a, b]`
`<Expression>    FLOAT     = Array[4, 2, 2, 2, 2, 2, 2, 2]`
`IDL> help, [[[[a]]], [[[b]]]]`
`<Expression>    FLOAT     = Array[2, 2, 2, 4, 2, 2, 2, 2]`
`IDL> help, [[[[[[[[a]]]]]]], [[[[[[[b]]]]]]]]`
`<Expression>    FLOAT     = Array[2, 2, 2, 2, 2, 2, 2, 4]`

### Data Type for Array Concatenation

When you use array concatenation, IDL will automatically choose the data type for the final array based upon the data types of the individual elements. Any elements which are not of the correct data type will be converted. For example:

`a = [0.5, 1, 2, 3, 4] ; float with integers`
`help, a`
`b = [a, 5d] ; append a double-precision value`
`help, b`

IDL prints:

`A               FLOAT     = Array`
`B               DOUBLE    = Array`

See Data Type and Structure of Expressions for the rules used when promoting types.

## Array Creation Functions

The IDL functions for array creation fall into two groups:

• The "*ARR" group (such as FLTARR) which are used to construct arrays filled with zero values, and
• The "*INDGEN" group (such as FINDGEN) which are used to construct arrays filled with increasing (or decreasing) values.

The prefix in front of each function determines the result type. For example BYTARR returns byte arrays, while UINTARR

All of these functions have the same general syntax. For example:

• Result = FLTARR( D1[, ..., D8] [, /NOZERO] )
• Result = FINDGEN( D1 [, ..., D8] [, INCREMENT=value] [, START=value])

Here, the D1[, ..., D8] represent the size of each dimension of the result. You can also specify the dimensions by providing an array for the first argument.

For the *ARR family, you can use the NOZERO keword to avoid setting each element to zero.

For the *INDGEN family, you can use the START and INCREMENT keywords to construct arrays that start at a non-zero value and have a spacing that is greater or smaller than 1.

For example:

 Command Result print, FLTARR(5) 0.000000 0.000000 0.000000 0.000000 0.000000 help, FLTARR(360, 180, 10) FLOAT = Array[360, 180, 10] print, INDGEN(10) 0 1 2 3 4 5 6 7 8 9 print, MAX(LINDGEN(1000, 100)) 99999 print, INDGEN(5, START=10, INCREMENT=5) 10 15 20 25 30 print, INDGEN(10, INCREMENT=0.5) 0 0 1 1 2 2 3 3 4 4 print, FINDGEN(10, INCREMENT=0.5) 0.000000 0.500000 1.00000 1.50000 2.00000 2.50000 3.00000 3.50000 4.00000 4.50000

You can also use the following routines to create more specialized arrays:

• IDENTITY: Returns an identity array (an array with ones along the main diagonal and zeros elsewhere).
• MAKE_ARRAY: Returns an array of the specified type, dimensions, and initialization.
• REPLICATE: Creates an array of given dimensions, filled with specified value.
• TIMEGEN: Returns an array of Julian dates and times.

See Array Creation for a complete list of routines.

## Colon Operator

You can use the colon ":" operator to construct arrays with increasing or decreasing values. The colon operator provides a more readable, short-hand syntax for the *INDGEN family of functions.

The operator has the following syntax:

Result = [start: finish]

or

Result = [start: finish: increment]

With the first form (without an increment), the increment is assumed to be 1 if finish is greater than or equal to start, or -1 if finish is less than start. For example,

`PRINT, [0:9]`
`PRINT, [9:0]`

IDL prints:

`0       1       2       3       4       5       6       7       8       9`
`9       8       7       6       5       4       3       2       1       0`

With the second form (with an increment), you are responsible for making sure that the increment has the correct sign. For example, if finish is less than start then your increment should be negative.

Note: You will get a runtime error if increment is zero or is the wrong sign.

Note: If any of the arguments is equal to !NULL the result will also be !NULL.

### Data Type for Array Concatenation

When you use the colon operator, IDL will automatically choose the data type for the final array based upon the data types of the arguments. For example:

`a = [0: 1: 0.1] ; integers with a float stride`
`HELP, a`
` `
`b = [0L: 10: 2] ; one of the integers is a long`
`HELP, b`

IDL prints:

`A               FLOAT     = Array`
`B               LONG   = Array`

See Data Type and Structure of Expressions for the rules used when promoting types.

### Examples

 INDGEN Command Colon Operator Result INDGEN(10) [0:9] 0 1 2 3 4 5 6 7 8 9 9 - INDGEN(10) [9:0] 9 8 7 6 5 4 3 2 1 0 INDGEN(10) [0:9:1] 0 1 2 3 4 5 6 7 8 9 9 - INDGEN(10) [9:0:-1] 9 8 7 6 5 4 3 2 1 0 10 + 5*INDGEN(5) [10:30:5] 10 15 20 25 30 0.5*FINDGEN(7) [0:3:0.5] 0.0 0.5 1.0 1.5 2.0 2.5 3.0

You can use the colon operator anywhere that you use an IDL expression. For example, you could combine array concatenation with the colon operator:

`arr = [[1:5], [6:10], 11, [11:16], 17, 18, 19, 20, [21:30]]`
`HELP, arr`

IDL prints:

`ARR               INT       = Array`

You can create two and three-dimensional arrays by combining the colon operator with array concatenation. For example:

`a = [[10:19], [20:29], [30:39]]`
`HELP, a`
`PRINT, a`

IDL prints:

`A               INT       = Array[10, 3]`
` `
`10 11 12 13 14 15 16 17 18 19`
`20 21 22 23 24 25 26 27 28 29`
`30 31 32 33 34 35 36 37 38 39`

You can also use the colon operator as the argument in a FOREACH statement:

`FOREACH x,[0:1:0.2] DO PRINT, x`

IDL prints:

`0.000000`
`0.200000`
`0.400000`
`0.600000`
`0.800000`
`1.00000`