Multi-dimensional array: Difference between revisions

{{task}}

# State the number and extent of each index to the array.

# Provide specific, ordered, integer indices for all dimensions of the array together with a new value to update the indexed value.

# Provide specific, ordered, numeric indices for all dimensions of the array to obtain the arrays value at that indexed position.

 

* State if the language supports multi-dimensional arrays in its syntax and usual implementation.

* State whether the language uses [https://en.wikipedia.org/wiki/Row-major_order row-major or column major order] for multi-dimensional array storage, or any other relevant kind of storage.

* State if memory allocation is optimised for the array - especially if contiguous memory is likely to be allocated.

* If the language has exceptional native multi-dimensional array support such as optional bounds checking, reshaping, or being able to state both the lower and upper bounds of index ranges, then this is the task to mention them.

 

Show all output here, (but you may judiciously use ellipses to shorten repetitive output text).

 

=={{header|Ada}}==

 

Ada array indices employ the concept of a range. A range is specified as Low_Value .. High_Value. The range is inclusive of both the low value and the high value.

type Grade is range 0..100;

subtype Lower_Case is Character range 'a'..'z';

subtype Positive is Integer range 1..Integer'Last;

type Deflection is range -180..180;

Grade is defined as a distinct integer type with valid values from 0 through 100.

Ada array types may be constrained types or unconstrained types. A constrained type is defined with a constrained index range. An unconstrained type is defined with an unconstrained index range. All instances of an unconstrained array type are themselves constrained.

{{Single dimensional arrays}}

type Char_Array is array (0..9) of Character; -- A constrained array of characters

type String is array (Positive range <>) of Character; -- An unconstrained array of characters

All instances of Char_Array as defined above have a length of 10 characters with a lower index bound of 0 and an upper index bound of 9. The definition of the type String above is the standard Ada definition for a fixed length string type. Within the index definition we see "Positive range <>". This indicates that an instance of type String must have an index range within the valid range for the pre-defined integer subtype named Positive. Positive is defined as all integer values beginning at 1 and continuing to the highest integer value. The definition of Positive is

subtype Positive is Integer range 1..Integer'Last;

String literals are indexed beginning at index value 1.

Name : String := "Rosetta Code";

The instance of string identified as Name above is created and initialized to hold the value "Rosetta Code". The first index value for Name is 1. The last index value for Name is 12.

 

 

''''Length''' This attribute returns the number of array elements of a single-dimensional array.

Num_Elements : Natural := Char_Array'Length;

 

''''Length(N)''' This attribute returns the number of elements for the Nth of an array.

 

Ada allows the definition of an array type which is any array of another array type.

type Vector is array (1..10) of Integer;

type Table is array (0..99) of Vector;

In this example, one can access the second element of an instance of type Vector using the notation

V : Vector;

...

V(2) := 10;

Accessing the second element of the vector on the second row of Table is done as

T : Table;

...

T(1)(2) := 10;

Each element of Table is an instance of Vector. Each element of Vector is an Integer.

 

 

Ada also allows the definition of multi-dimensional arrays.

type Matrix is array (0..99, 1..10) of Integer;

M : Matrix;

...

M(1,2) := 10;

The example above shows how to access the element in the second row and second column of an instance of Matrix.

 

Whole array instances can be assigned to other arrays of the same type.

Mat1 : Matrix;

Mat2 : Matrix;

...

Mat1 := Mat2;

The above assignment creates a deep copy. After the assignment Mat1 and Mat2 are separate instances of Matrix containing the same values.

 

Slices of arrays can also be assigned to instances of the same array type such as

V1 : Vector := (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

V2 : Vector := (2, 2, 2, 2, 2, 2, 2, 2, 2, 2);

...

V2(3..6) := V1(7..10);

When assigning whole arrays or slices of arrays the sizes must match, but the index ranges can be different. In the example above each slice contains 4 data elements. The value of V2 after the assignment is (2, 2, 7, 8, 9, 10, 2, 2, 2, 2).

 

 

The Ada "for" loop is used to iterate through arrays without danger of index bounds violations

function "*" (Left : Vector; Right : Integer) return Vector is

Result : Vector;

return Result;

end "*"

The function definition above overloads the multiplication operator "*" allowing the multiplication of every element of and instance of Vector by an Integer value. The "for" loop within the function iterates over each value of the range produced using the 'Range attribute. Unlike some languages such as C or C++, no additional parameter specifying the number of elements in the array is passed. This approach works well for constrained array types. A small variation is used for unconstrained array types.

type Unconstrained_Vector is array (Positive range <>) of Integer;

U1 : Unconstrained_Vector := (1,2,3,4,5,6,7,8,9,10);

return Result;

end "*";

The instance of Unconstrained_Vector defined within the function is initialized to have the same index values as the formal parameter named Left. This version of the function allows the programmer to pass any instance of Unconstrained_Vector to the function "*". In the example above one may pass both U1 and U2 to the function without experiencing index boundary violation.

 

The upper and lower bounds are separated by ":" and each pair of bounds is separated from the next by a ",".

The array required by the task could be declared as follows: #

As the lower bounds are all 1, this could be abbreviated to:

Note that the lower and upper bounds can be 0 or negative, e.g. the following declares an array of the same size but different bounds:

Individual array elements can be set and accessed by stating the index values separated by ",".

The following sets the lowest element of the array to 0:

The following sets the highest element to the lowest:

Subsets of the array can be set and accessed by stating the index values of the subsets,

e.g. the following sets a pair of elements near the start of the array to a pair of elements near the end:

Selecting a subset of an array is known as slicing.

The whole array can also be assigned, e.g., the following sets the entire array to some values, using nested "literal arrays" (known as row-displays):

a := ( ( ( ( 1111, 1112 ), ( 1121, 1122 ), ( 1131, 1132 ) )

, ( ( 1211, 1212 ), ( 1221, 1222 ), ( 1231, 1232 ) )

, ( ( 5211, 5212 ), ( 5221, 5222 ), ( 5231, 5232 ) )

, ( ( 5311, 5312 ), ( 5321, 5322 ), ( 5331, 5332 ) )

If the lower bounds are not 1, they can be temporarily be changed to 1 by using the "AT" construct, e.g. as in the following:

 

[ 2 : 6, 2 : 5, 2 : 4, 2 : 3 ]INT b;

 

, ( ( 5211, 5212 ), ( 5221, 5222 ), ( 5231, 5232 ) )

, ( ( 5311, 5312 ), ( 5321, 5322 ), ( 5331, 5332 ) )

Bounds checking is standard and there is no standard way to turn it off. There may be implementation-specific mechanisms (probably using pragmatic comments) to do so.

 

The bounds of the array can be determined using the LWB and UPB operators.

For a 1 dimensional array, the unary LWB and UPB operators can be used.

# indexes of a ( in this case, 1, 5, 1 and 4 ) #

{{out}}

<pre> +1 +5 +1 +4</pre>

The upper and lower bounds are separated by "::" and each pair of bounds is separated from the next by a ",".

The array required by the task could be declared as follows:

note that the lower and upper bounds can be 0 or negative, e.g. the following declares an array of the same size but different bounds:

 

individual array elements can be set and accessed by stating the index

values separated by ",". The following sets the lowest element of the array to 0:

 

The following sets the highest element to the lowest:

 

Subsets of an array can be specified as parameters to procedures.

E.g.:

procedure p ( integer array a1 ( *, *, * ) ) ; a1( 1, 2, 1 ) := 3 ;

 

% call the procedure with a subset of the 4 dimensional array %

 

The elements of the array can only be set individually, it is not possible to assign

=={{header|C}}==

C supports multi-dimensional arrays, and thanks to the inter-op of arrays and points in C, it is possible to target any section of memory and drill down to the bit level. C uses row-major order for storing arrays. There are many ways to declare arrays, or pointers which can then be used as arrays, as shown below :

int a[10];

 

/*you get the idea*/

 

When arrays are declared with all dimensions at the outset, all memory is allocated immediately once the program execution reaches the point where the array is declared. The following implementation shows just a few of the many ways of dealing with arrays :

#include<stdio.h>

 

return 0;

}

Output :

<pre>

</pre>

Declared as above or by using the functions malloc or calloc of the C Standard Library, memory is allocated contiguously. This obviously assumes that the machine has sufficient memory. The following implementation shows how a multi pointer can work as an array :

 

#include<stdlib.h>

return 0;

Output :

<pre>

C# supports both multidimensional arrays and jagged arrays (e.g. arrays of arrays).<br/>

A multidimensional array with 2 rows and 3 columns can be initialized with:

{ 1, 2, 3 },

{ 4, 5, 6}

 

//To create a 4-dimensional array with all zeroes:

Under the hood, this is just one object; one contiguous block of memory is allocated.<br/>

 

For jagged arrays, each dimension must be initialized separately. They can be non-rectangular.

new [] { 1, 2, 3, 4 },

new [] { 5, 6, 7, 8, 9, 10 }

}

}

 

C# also supports arrays with non-zero bounds (mainly for handling arrays that are returned from unmanaged code)

int n = 1;

//Note: GetUpperBound is inclusive

//The multidimensional array does not implement the generic IEnumerable<int>

//so we need to cast the elements.

{{out}}

<pre>

 

=={{header|C++}}==

#include <vector>

 

 

return 0;

{{out}}

<pre>[[[[0, 1, 2, 3]], [[4, 5, 6, 7], [8, 9, 10, 11]]], [[[12, 13, 14, 15]]]]</pre>

 

=={{header|D}}==

 

/*

nativeExample();

customArray();

{{out}}

<pre>Static array: [1, 2, 3]

[5, 4, 4]

[5, 5, 5]]</pre>

 

=={{header|EchoLisp}}==

EchoLisp natively supports 1 and 2-dimensions arrays : lib '''matrix'''. The following shows an implementation of multi-dimensional arrays, using contiguous memory and bound checking. Indices are vectors #(i j k ...) of integers.

 

;; dims = vector #(d1 d2 .....)

(define (m-array-set! ma indices value )

(m-array-check ma indices)

{{out}}

<pre>(define MA (make-m-array #(5 4 3 2) 1))

Factor supports multi-dimensional arrays via the <code>arrays.shaped</code> vocabulary. Factor has no widespread syntax for array indexing, so support is provided in the form of words. Both row-major and column-major indexing are available. The underlying data structure of a <code>shaped-array</code> is a flat, contiguous array. <code>arrays.shaped</code> provides an optional word for bounds-checking, <code>shaped-bounds-check</code>, and a word to reshape an array, <code>reshape</code>.

{{works with|Factor|0.99 2020-10-27+}}

 

! Create a 4-dimensional array with increasing elements.

! Reshape and show the array.

"Reshaped: " print

{{out}}

<pre>

}

}

</pre>

 

=={{header|Fortran}}==

Messing with multi-dimensional arrays has been central from the introduction of Fortran in 1954. Array indexing is with positive integers and always starts with one, so the DIMENSION statement merely specifies the upper bound of an index via integer constants and an array may have up to three dimensions. All storage for an array is contiguous. Access to an element of a one-dimensional array A is via <code>A(''integer expression'')</code> and early Fortran allowed only simple expressions, no more than c*v ± b which is to say an integer constant times an integer variable plus (or minus) an integer constant. These restrictions simplified the thorough optimisation done by the first compiler. Later compilers abandoned those optimisations, relaxed the constraints on index expressions and allowed more dimensions.

X = 3*A(2,I,1,K) !Extracts a certain element, multiplies its value by three, result to X.

Compilers typically perform no checking on the bounds of array indices, even when values are being written to some address. An immediate crash would be the best result. Array bound checking may be requested as a compiler option in some cases, resulting in larger code files, slower execution, and some bug detection.

 

As well, array data could be manipulated with array processing statements, rather than always having to prepare DO-loops or similar, in particular <code>A = 0</code> would set all values of array A to zero, whatever its dimensionality. Thus, given an array B(0:2,0:2), a two-dimensional array, <code>B(1:2,1:2) = 6*A(1,3:4,1,1:2) - 7</code> would select certain elements scattered about in A, perform the calculation, and store the results in a part of B. Hopefully, element-by element without using a temporary array. Even more complicated selections can be made via the RESHAPE intrinsic now available.

 

DATA A/1,2,3, !Some initial values.

2 4,5,6, !Laid out as if a matrix.

WRITE (6,1) (A(I,J), J = 1,3) !The columns along a row.

END DO !Onto the next row.

Output:

<pre> Writing A...

 

For large arrays when memory is not truly random-access (on-chip memory versus main memory, main memory versus slower disc storage) a calculation that works along a row will be accessing widely-separated elements in storage, perhaps with only one "hit" per virtual memory page before leaping to another, while an equivalent calculation working down a column will enjoy multiple hits per page. The difference can be large enough to promote usages such as swapping the order of the DO-loops for portions of a calculation, or swapping the order of the indices as by writing <code>A(J,I)</code> when it would be more natural to use <code>A(I,J)</code>.

 

=={{header|Go}}==

 

The technique shown here defines a multi-dimensional array type. A constructor allocates a single slice as a flattened representation. This will be a single linear memory allocation. Methods access the slice in row-major order.

 

import "fmt"

fmt.Println(m.ele[len(m.ele)-10:])

m.show(4, 3, 2, 1)

{{out}}

<pre>m[4 3 2 1] = 0

Perhaps the simplest mechanism to create a multidimensional array is to reshape a smaller dimensioned array with the desired dimensions:

 

This creates an array of 120 zeros arranged in contiguous memory.

 

Note that items along the leading dimension of the array being reshaped are repeated as necessary to fill in all the values of the array. Thus, this is equivalent:

Another candidate for the simplest mechanism to create a multidimensional array is to ask for an array of indices with those dimensions:

0 1 2 3 4

5 6 7 8 9

105 106 107 108 109

110 111 112 113 114

 

Note that these indices are not multi-dimensional indices but simple counting numbers. (Internally, values in the array are arranged contiguously and in this index order.) To obtain the corresponding index, you can use J's antibase verb. For example:

 

 

Normally, in J, you operate on "everything at once", which can be challenging if you have not worked in a language (such as sql or any of a variety of others) which encourages that kind of thinking. Nevertheless, here's some introductory "one at a time" operations:

 

Pulling a single value from an array:

Setting a single value in an array:

And, to reduce vertical space used in this task, here's an example of extracting a sub-array:

100 101 102 103 104

105 106 107 108 109

110 111 112 113 114

 

Note that bounds are checked when indexing from the array, or when combining with another array.

and

 

For more introductory material on multi-dimensional arrays, you might be interested in [http://www.jsoftware.com/help/learning/05.htm chapter 5] and [http://www.jsoftware.com/help/learning/07.htm chapter 7] of the Learning J book.

{{trans|Kotlin}}

Same description for limitations of the JVM apply here as is described in the Kotlin implementation of the task.

public static void main(String[] args) {

// create a regular 4 dimensional array and initialize successive elements to the values 1 to 120

}

}

{{out}}

<pre>First element = 1

 

One approach pairs an array of dimensions with an array of values.

var dimensions= Array.prototype.slice.call(arguments);

var N=1, rank= dimensions.length;

this.dimensions= dimensions;

this.values= new Array(N);

 

A routine to convert between single dimension indices and multi-dimensional indices can be useful here:

 

var r= 0, len= base.length;

for (j= 0; j < len; j++) {

}

return r;

For example, array indexing in this approach might be implemented something like:

 

array.prototype.index= function() {

var indices= Array.prototype.slice.call(arguments);

return this.values[tobase(this.dimensions, indices)];

}

This would allow things like:

 

But a proper implementation of the index method should include array bounds checking.

 

Another approach "nests" arrays inside other arrays:

function array(length) {

var rest= Array.prototype.slice.call(arguments);

}

}

This approach is superficially simpler but may turn out to be considerably slower.

 

To create a multi-dimensional array with dimensions specified by an

array, d, we can define a recursive function as follows:

# multi-dimensional array:

def multiarray(d):

| if (d|length) == 1 then [range(0;d[0]) | $in]

else multiarray(d[1:]) | multiarray( d[0:1] )

A four-dimensional array as specified by the task description can now be created as follows:

For convenience of reference, let us name this array by wrapping it in

a function:

 

'''Access and Update'''

To access the [4,3,2,1] element of the previously defined multi-dimensional array, one can either write:

or

 

To illustrate, let us define an array of indices:

 

To check that the two approaches for accessing an element are equivalent:

#=> 100

 

ary | setpath(ix; 100) | .[4][3][2][1]

 

'''Ascertaining the Dimensions of a Multi-dimensional Array'''

regular multi-dimensional array; it returns [] for a scalar, and null

for an irregularly shaped array:

def same(f):

if length == 0 then true

end

else []

 

For exampe:

 

=={{header|Julia}}==

<br /><br />

Demonstrated below, from a Julia REPL session, using a random integer four-dimensional array:

julia> a4d = rand(Int, 5, 4, 3, 2)

5×4×3×2 Array{Int64,4}:

julia> a4d[4,3,2,1]

2213007499408257641

 

=={{header|Klingphix}}==

 

0 ( 4 3 2 ) dim pstack

pstack

 

 

=={{header|Kotlin}}==

 

Arrays in Kotlin always start from an index of zero and, in the version which targets the JVM, bounds are checked automatically.

 

fun main(args: Array<String>) {

print(f.format(a4[i][j][k][l]))

 

{{out}}

<pre>First element = 1

Lingo has no special multi-dimensional array support, but such arrays can be implemented based on nested lists.<br />

(Note: code partially stolen from Lua solution).

cnt = paramCount()

if cnt=0 then return

end repeat

return arr

 

a = array(2, 3, 4, 5)

put a[1][2][3][4]

a[1][2][3][4] = 42

put a[1][2][3][4]

 

=={{header|Lua}}==

Lua does not support straightforward declaration of multidimensional arrrays but they can be created in the form of nested tables. Once such a structure has been created, elements can be read and written in a manner that will be familiar to users of C-like languages.

function multiArray (initVal, ...)

local function copy (t)

show4dArray(t)

t[1][1][1][1] = true

{{out}}

<pre>Printing 4D array in 2D...

4 a a a a a</pre>

This is not memory-efficient and any advanced operations will have to be written if required. A much easier solution is to use an extension module such as densearray available from luarocks.org.

 

=={{header|Nim}}==

Here are some examples:

 

 

let c = [

# |1.0 1.0 1.0|

# |1.0 1.0 1.0|

 

=={{header|Perl}}==

 

# Perl arrays are internally always one-dimensional, but multi-dimension arrays are supported via references.

$d[2] = 'Wed';

@d[3..5] = @d[reverse 3..5];

 

=={{header|Phix}}==

sub-sequences, and can easily be shrunk or expanded, at any level, at any time.

 

<span style="color: #004080;">sequence</span> <span style="color: #000000;">xyz</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x</span><span style="color: #0000FF;">),</span><span style="color: #000000;">y</span><span style="color: #0000FF;">),</span><span style="color: #000000;">z</span><span style="color: #0000FF;">)</span>

 

or if you prefer:

 

<span style="color: #004080;">sequence</span> <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">x</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">plane</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">space</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">plane</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">)</span>

 

Internally Phix uses reference counting with copy-on-write semantics, so the initial space allocated is x+y+z, and as

Note that all indexes are 1-based. You can also use negative indexes to count backwards from the end of the sequence.

 

<span style="color: #004080;">sequence</span> <span style="color: #000000;">rqd</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span><span style="color: #000000;">3</span><span style="color: #0000FF;">),</span><span style="color: #000000;">4</span><span style="color: #0000FF;">),</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span>

<span style="color: #000000;">row</span> <span style="color: #000080;font-style:italic;">-- scratch var</span>

<span style="color: #000000;">rqd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">5</span><span style="color: #0000FF;">][</span><span style="color: #000000;">4</span><span style="color: #0000FF;">][</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- middle element of rqd[5][4] is now longer than the other two</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">rqd</span><span style="color: #0000FF;">[</span><span style="color: #000000;">5</span><span style="color: #0000FF;">][</span><span style="color: #000000;">4</span><span style="color: #0000FF;">]</span>

 

{{out}}

an easily readable fashion:

 

<span style="color: #0000FF;">?</span><span style="color: #008000;">"==1=="</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rqd</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #008000;">"==3=="</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rqd</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">pp_Nest</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">})</span>

 

{{out}}

 

=={{header|Phixmonti}}==

 

0 ( 5 4 3 2 ) dim

0 10 repeat ( 5 4 2 ) sset

 

 

=={{header|Python}}==

 

Function <code>dict_as_mdarray</code> allows for the creation of an initialised multi-dimensional array of a given size. Note how indexing must use the round brackets of a tuple inside the square brackets of normal dict indexing:

>>> from itertools import product

>>>

(1, 2, 3, 3): 0.0,

(1, 2, 3, 4): 0.0}

 

===Python: numpy library===

 

The default is row-major order (compatible with C). When dealing with Fortran storage order, care must be taken in order to get the same behavious as in Fortran:

a = np.array([[1, 2], [3, 4]], order="C")

b = np.array([[1, 2], [3, 4]], order="F")

np.reshape(a, (4,)) # [1, 2, 3, 4]

np.reshape(b, (4,)) # [1, 2, 3, 4]

 

In Fortran, one would expect the result [1, 3, 2, 4].

>>>

>>> mdarray = zeros((2, 3, 4, 5), dtype=int8, order='F')

[ 0, 0, 0, 0, 0],

[ 0, 0, 0, 0, 0]]]], dtype=int8)

 

=={{header|Racket}}==

=={{header|Raku}}==

(formerly Perl 6)

 

my @integers = 1 .. Inf; # an infinite array containing all positive integers

my uint16 @d = 1 .. 10 # Since there are and only can be unsigned 16 bit integers, the optimizer will use a much more compact memory layout.

 

 

=={{header|REXX}}==

element &nbsp; '''2, 0''' &nbsp; (and set that value to the variable &nbsp; '''g'''), &nbsp; one could code &nbsp; (note

the use of periods after the variable name and also between the indices to the array dimensions:

Memory allocation for stemmed arrays is not optimized, and the array elements are not contiguous.

 

The index to the array dimensions may be any integer, and indeed, even non-numeric &nbsp; (and possible non-viewable).

b = '~' /*set variable B to a tilde character [~]. */

 

The REXX language does not do bounds checking, but if &nbsp; &nbsp; '''signal on novalue''' &nbsp; &nbsp; is in effect, it can be used to trap (read) references of array elements that haven't been assigned a value (at the time of the read reference).

/*REXX arrays can start anywhere. */

y.=0 /*set all values of Y array to 0. */

say 'y.' || i || . || k || . || m '=' y.i.j.k.m

say 'y.'||i||.||k||.||m '=' y.i.j.k.m

{{out|output}}

<pre>y.0.0.0.0 = 0

 

=={{header|Ring}}==

 

a4 = newlist4(5,4,3,2)

t = newlist3(y,z,w)

next

Output:

<pre>First element = 1

 

Arrays in Scala always start (of course as the great Dijkstra in his [https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html EWD831] pointed out) from an index of zero and, insofar the target machine can handle, bounds can be checked automatically e.g. by the JVM (throwing an exception) or ES aka JavaScript (resulting "undefined").

 

// Create a regular 4 dimensional array and initialize successive elements to the values 1 to 120

println(a4.flatten.flatten.flatten.mkString(", "))

 

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/Lx6AG4S/0 (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/MF2p1z1fReyhjGcu4aY4Eg Scastie (remote JVM)].

 

===lists===

Multi-dimensional lists are easily handled by nesting. Let's define a helper proc to construct such lists using lrepeat:

set res $value

foreach dim [lreverse $args] {

}

return $res

{{out}}

x x

% multilist x 2 3

{x x x} {x x x}

% multilist x 2 3 4

Both lset and lindex know how to access multi-dimensional lists:

{{0 0 0 0} {0 0 0 0} {0 0 0 0}} {{0 0 0 0} {0 0 0 0} {0 0 0 0}}

% lset ml 1 2 3 11

{{0 0 0 0} {0 0 0 0} {0 0 0 0}} {{0 0 0 0} {0 0 0 0 12} {0 0 0 11}}

% lindex $ml 1 2 3

[http://www.tcl.tk/man/tcl/TclCmd/lsort.htm lsort] and [http://www.tcl.tk/man/tcl/TclCmd/lsearch.htm lsearch] are among other useful commands that support nested lists.

===arrays===

Tcl arrays are collections of variables, not collections of values: thus they cannot nest. But since keys are simply strings, multidimensional data can be kept like this:

0,0 a

0,1 b

not c

% parray x $b,$a

Such an array can also be "sliced" with the array command:

1,0 c 1,1 d

% array names x 0,*

Note however that the order in which elements are returned from these operations is undefined! The last command might return {0,0 0,1} or {0,1 0,0} depending on how its keys are hashed, which is not under the programmer's control.

 

Using arrays like this for ordered data is suboptimal for this reason, and because iterating over elements is cumbersome. But it's a common technique for records:

1,name Fido

1,score 0

Fido is green and has 0 points

Scratchy is pink and has 99 points

The interested reader should also be aware of the difference between arrays and [http://www.tcl.tk/man/tcl/TclCmd/dict.htm dict]ionaries, and know that the latter are often preferred for record-like structures.

 

=={{header|Wren}}==

 

Otherwise what was said in the Kotlin preamble applies more or less to Wren.

 

// create a 4 dimensional list of the required size and initialize successive elements to the values 1 to 120

}

}

 

{{out}}

 

121 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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

</pre>