• Elixir

  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
  end

• Ada

X : array (1 .. M, 1 .. N, 1 .. P) of Float := (others => (others => (others => 1.0)));

• C

double ***x=malloc(m*sizeof(double **));
int i,j;
for(i=0;i<m;i++)
{
	x[i]=malloc(n*sizeof(double *));
	for(j=0;j<n;j++)
	{
		x[i][j]=malloc(p*sizeof(double));
	}
}

• C++

std::vector<std::vector<std::vector<double>>> x (m, std::vector<std::vector<double>> (n, std::vector<double> (p)));

• C#

var x = new double[m, n, p];

• D

auto x = new real[][][](m, n, p);

• Dart

var x = new List.generate(m, (_) => 
                new List.generate(n, (_) => 
                    new List.filled(p, 0.0), 
                    growable: false), 
                growable: false);

• Erlang

X = 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)].

• Fortran

  real, dimension(:,:,:), allocatable :: x

  allocate (x(m,n,p))

• Go

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
}

• Go

const m, n, p = 2, 2, 3
var x [m][n][p]float64

• Go

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
}

• Haskell

x = [ [ [ k**(i/j) | k<-[1..p] ] | j<-[1..n] ] | i<-[1..m] ]

• JS

const x = new Array(m).fill(
  new Array(n).fill(
    new Array(p).fill(Math.random())
  )
)

• Java

double[][][] x = new double[m][n][p];

• Java

BigDecimal x[][][] = new BigDecimal[m][n][p];

• Kotlin

val x = Array(m, { Array(n, { DoubleArray(p) } ) } )

• Lisp

(defparameter *x*
  (make-array (list m n p)
              :element-type 'double-float
              :initial-element 0.0d0))

• Lua

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
end

• Obj-C

NSArray *x=@[
  @[
    @[@0.1, @0.2, ... ], // p column values
    ... // n sub-rows
  ],
  ... // m rows
];

• PHP

$x = array_fill(0, $m, array_fill(0, $n, array_fill(0,$p,0)));

• Pascal

var x: array [m,n,p] of double;

• Perl

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, ] ]
];

• Perl

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++;
        }
    }
}

• Python

f = lambda: [*repeat([.0] * p, m)]
x = [*repeat(f(), n)]

• Python

x = []
for a in range(m):
    t = []
    for b in range(n):
        t.append([.0] * p)
    x.append(t)

• Python

x = [[[0 for k in range(p)] for j in range(n)] for i in range(m)]

• Python

x = numpy.zeros((m,n,p))

• Ruby

x = Array.new(m) { Array.new(n) { Array.new(p) } }

• Rust

let x = vec![vec![vec![0.0f64; p]; n]; m];

• Rust

let x = [[[0.0f64; P]; N]; M];