Logo

Programming-Idioms

This language bar is your friend. Select your favorite languages!
  • Go

Idiom #26 Create a 2-dimensional array

Declare and initialize a matrix x having m rows and n columns, containing real numbers.

func make2D(m, n int) [][]float64 {
	buf := make([]float64, m*n)

	x := make([][]float64, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}

This works even when m, n are not compile-time constants.
This code allocates one big slice for the numbers, plus one slice for x itself.
The same function would have to be rewritten, for types other than float64.
const m, n = 3, 4
var x [m][n]float64

m, n must be constant for this syntax to be valid.
Here x is of type [3][4]float64, it is not a slice.
func make2D[T any](m, n int) [][]T {
	buf := make([]T, m*n)

	x := make([][]T, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}

This generic func works for any type parameter T.
m, n do not need to be compile-time constants.
This code allocates one big slice for the elements, plus one slice for x itself.
X : array (1 .. M, 1 .. N) of Float := (others => (others => 1.0));
New implementation...
< > ⌨
programming-idioms.org 
func make2D(m, n int) [][]float64 {
	buf := make([]float64, m*n)

	x := make([][]float64, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}
const m, n = 3, 4
var x [m][n]float64
func make2D[T any](m, n int) [][]T {
	buf := make([]T, m*n)

	x := make([][]T, m)
	for i := range x {
		x[i] = buf[:n:n]
		buf = buf[n:]
	}
	return x
}
X : array (1 .. M, 1 .. N) of Float := (others => (others => 1.0));
double **x=malloc(m*sizeof(double *));
int i;
for(i=0;i<m;i++)
	x[i]=malloc(n*sizeof(double));
const int m = 2;
const int n = 3;
double x[m][n];
(for [i (range 1 (inc m))]
  (for [j (range 1 (inc n))]
    (* i j)))
::std::array<::std::array<int, n>, m> x;
std::vector<std::vector<double>> x (m, std::vector<double>(n));

var x = new double[m, n];
auto x = new double[][](m, n);
var x = new List.generate(m, (_) => new List(n));
var x = new List.generate(m, (_) => new List.filled(n, 0));
x = for _ <- 1..m, do: for _ <- 1..n, do: 0.0
X = [{R * 1.0, C * 1.0} || R <- lists:seq(1, M), C <- lists:seq(1, N)].
  real, dimension(m,n) :: x
x = [ [ j**(1/i) | j <- [1..n] ] | i <- [1..m] ]

const x = new Array(m).fill(new Array(n).fill(Math.random()));
var x = [];
for (var i = 0; i < m; i++) {
  x[i] = [];
}
double[][] x = new double[m][n];
BigDecimal x[][] = new BigDecimal[m][n];
val x = Array(m, { DoubleArray(n) })

(make-array (list m n)
   :element-type 'double-float
   :initial-element 1.0d0)
local x = setmetatable({},{
   __index = function(t1,k1)
      t1[k1] = setmetatable({},{
         __index = function(t2,k2)
            t2[k2] = 0
            return t2[k2]
         end
      })
      return t1[k1]
   end
})
x = {}
for i=1,m do
  x[i] = {}
  for j=1,n do
    x[i][j] = 0
  end
end
NSArray *x=@[
  @[@0.1, @0.2, ... ], // n column values
  ... // m rows
];
$x = array();
$x = array_pad($x, m, 1);
for($i = 0; $i < count($x); $i++){
  $x[$i] = array();
  $x[$i] = array_pad($x[$i],n,1);
}

$m = 3;
$n = 4;

$x = array_map(
    function () use ($m) { return array_fill(0, $m, 0); },
    range(1, $n)
);
var _x: array[_m,_n] of Double;
my @array = (
   [ 1.0, 0.0, 0.0 ],
   [ 0.0, 1.0, 0.0 ],
   [ 0.0, 0.0, 1.0 ],
   "first three slots are a 3x3 identity matrix",
   "fourth and fifth slots contain strings"
);
   
x = [[0] * n for _ in range(m)]
x = []
for i in range(m):
    x.append([.0] * n)
x = [*repeat([.0] * n, m)]
x = Array.new(m) { Array.new(n) }
let mut x = [[0.0; N] ; M];
let mut x = vec![vec![0.0f64; N]; M];
val x = Array.ofDim[Double](m,n)
(build-list m (lambda (x)
                (build-list n (lambda (y) 0))))
x := Matrix	
    rows: m
    columns: n
    element: 1.0
Dim x(m - 1, n - 1) As Double