Be concise.
Be useful.
All contributions dictatorially edited by webmasters to match personal tastes.
Please do not paste any copyright violating material.
Please try to avoid dependencies to third-party libraries and frameworks.
- Ada
- C
- C++
- C#
- D
- Dart
- Elixir
- Erlang
- Fortran
- Go
- Go
- Go
- Haskell
- JS
- Java
- Java
- Kotlin
- Lisp
- Lua
- Obj-C
- PHP
- Pascal
- Perl
- Perl
- Python
- Python
- Python
- Python
- Ruby
- Rust
- Rust
X : array (1 .. M, 1 .. N, 1 .. P) of Float := (others => (others => (others => 1.0)));auto x = new real[][][](m, n, p);multi-dim array initialization cannot put dimensions inside the brackets, it must be done this way.
var x = new List.generate(m, (_) =>
new List.generate(n, (_) =>
new List.filled(p, 0.0),
growable: false),
growable: false);Dart does not have multidimensional arrays as a primitive, this is a list of lists of lists of doubles, all fixed-length lists.
def main(m, n, p) do
if m == 0 or n == 0 or p == 0 do
[]
else
for _ <- 1..m, do: for _ <- 1..n, do: for _ <- 1..p, do: 0
end
endX = array(M, N, P).
-spec array(pos_integer(), pos_integer(), pos_integer()) -> [[[float()]]].
array(M, N, P) -> [array(M, N) || _ <- lists:seq(1, P)].
array(M, N) -> [array(M) || _ <- lists:seq(1, N)].
array(M) -> [rand:uniform() || _ <- lists:seq(1, M)]. real, dimension(:,:,:), allocatable :: x
allocate (x(m,n,p))
func make3D(m, n, p int) [][][]float64 {
buf := make([]float64, m*n*p)
x := make([][][]float64, m)
for i := range x {
x[i] = make([][]float64, n)
for j := range x[i] {
x[i][j] = buf[:p:p]
buf = buf[p:]
}
}
return x
}This works even when m, n, p are not compile-time constants.
This code allocates one big slice for the numbers, then a few slices for intermediate dimensions.
To same function would be rewritten, for types other than float64.
This code allocates one big slice for the numbers, then a few slices for intermediate dimensions.
To same function would be rewritten, for types other than float64.
const m, n, p = 2, 2, 3
var x [m][n][p]float64m, n, p must be constant for this syntax to be valid.
Here x is of type [2][2][3]float64, it is not a slice.
Here x is of type [2][2][3]float64, it is not a slice.
func make3D[T any](m, n, p int) [][][]T {
buf := make([]T, m*n*p)
x := make([][][]T, m)
for i := range x {
x[i] = make([][]T, n)
for j := range x[i] {
x[i][j] = buf[:p:p]
buf = buf[p:]
}
}
return x
}This generic func works for any type parameter T.
m, n, p do not need to be compile-time constants.
This code allocates one big slice for the elements, then a few slices for intermediate dimensions.
m, n, p do not need to be compile-time constants.
This code allocates one big slice for the elements, then a few slices for intermediate dimensions.
x = [ [ [ k**(i/j) | k<-[1..p] ] | j<-[1..n] ] | i<-[1..m] ]
const x = new Array(m).fill(
new Array(n).fill(
new Array(p).fill(Math.random())
)
)double[][][] x = new double[m][n][p];Initial values are 0.0
m, n, p need not be known at compile time
m, n, p need not be known at compile time
(defparameter *x*
(make-array (list m n p)
:element-type 'double-float
:initial-element 0.0d0))local x = {}
for i=1,m do
x[i] = {}
for j=1,n do
x[i][j] = {}
for k=1,p do
x[i][j][k] = 0
end
end
endsee http://www.programming-idioms.org/idiom/26/create-a-2-dimensional-array/1658/lua# for a lazy initialization
NSArray *x=@[
@[
@[@0.1, @0.2, ... ], // p column values
... // n sub-rows
],
... // m rows
];
Object arrays are one-dimensional, but can contain nested arrays (accessible later, if needed, through x[i][j][k] all right). With plain-C types it would be precisely same as in plain C. Compare also idiom #26
$x = array_fill(0, $m, array_fill(0, $n, array_fill(0,$p,0)));var x: array [m,n,p] of double;my $array3d = [
[ [ 1, 0, 1 ],
[ 0, 0, 0 ],
[ 1, 0, 1 ] ],
[ [ 0, 0, 0 ],
[ 0, 2, 0 ],
[ 0, 0, 0 ] ],
[ [ 3, 0, 3, ],
[ 0, 0, 0, ],
[ 3, 0, 3, ] ]
];Array variables are only one-dimensional, but arrays-of-arrays using array references can represent multi-dimensional arrays.
my @x;
my ($m, $n, $p) = (4,3,2);
my $v = 0;
foreach my $mx (0..$m-1) {
foreach my $nx (0..$n-1) {
foreach my $px (0..$p-1) {
$x[$mx][$nx][$px] = $v++;
}
}
}
Sample boundaries are 4, 3, 2 and filled with integers. Perl will "autovivify" lists (i.e. add new elements) as they are referenced and grow the arrays on the fly.
x = []
for a in range(m):
t = []
for b in range(n):
t.append([.0] * p)
x.append(t)x = numpy.zeros((m,n,p))NumPy is a third-party library for scientific computing.
x = Array.new(m) { Array.new(n) { Array.new(p) } }