Wolfram Language & System Documentation Center

Do[expr,n]

evaluates expr n times.

Do[expr,{i,i_max}]

evaluates expr with the variable i successively taking on the values 1 through i_max (in steps of 1).

Do[expr,{i,i_min,i_max}]

starts with i=i_min.

Do[expr,{i,i_min,i_max,di}]

uses steps di.

Do[expr,{i,{i₁,i₂,…}}]

uses the successive values i₁, i₂, ….

Do[expr,{i,i_min,i_max},{j,j_min,j_max},…]

evaluates expr looping over different values of j etc. for each i.

Do

Do[expr,n]

evaluates expr n times.

Do[expr,{i,i_max}]

evaluates expr with the variable i successively taking on the values 1 through i_max (in steps of 1).

Do[expr,{i,i_min,i_max}]

starts with i=i_min.

Do[expr,{i,i_min,i_max,di}]

uses steps di.

Do[expr,{i,{i₁,i₂,…}}]

uses the successive values i₁, i₂, ….

Do[expr,{i,i_min,i_max},{j,j_min,j_max},…]

evaluates expr looping over different values of j etc. for each i.

Details

Do uses the standard Wolfram Language iteration specification.
You can use Return, Break, Continue, and Throw inside Do.
Unless an explicit Return is used, the value returned by Do is Null.
Do[expr,Infinity] continues evaluating expr until explicitly told to exit through a function such as Break, Return, Throw, Abort, or Quit.
Do[expr,spec] first evaluates spec, then localizes the variable specified and successively assigns values to it, each time evaluating expr.
Do effectively uses Block to localize values or variables.
Do[expr,spec₁,spec₂] is effectively equivalent to Do[Do[expr,spec₂],spec₁].
Parallelize[Do[expr,iter]] or ParallelDo[expr,iter] computes Do[expr,iter] in parallel on all subkernels. »

Examples

open all close all

Basic Examples (3)

Print the first four squares:

Wolfram Language code: Do[Print[n ^ 2], {n, 4}]

n goes from -3 to 5 in steps of 2:

Wolfram Language code: Do[Print[n], {n, -3, 5, 2}]

Print 4 random integers:

Wolfram Language code: Do[Print[RandomInteger[10]], 4]

Scope (8)

Evaluate Print[x] twice:

Wolfram Language code: Do[Print[x], {2}]

The step can be negative:

Wolfram Language code: Do[Print[i], {i, 10, 8, -1}]

The values can be symbolic:

Wolfram Language code: Do[Print[n], {n, x, x + 3y, y}]

Loop over i and j, with j running up to i-1:

Wolfram Language code: Do[Print[{i, j}], {i, 4}, {j, i - 1}]

The body can be a procedure:

Wolfram Language code: t = 67;Do[Print[t];t = Floor[t / 2], {3}]

Break breaks out of Do:

Wolfram Language code: t = 1;Do[t *= k;Print[t];If[t > 19, Break[]], {k, 10}]

Continue continues the loop, without executing the rest of the body:

Wolfram Language code: t = 1;Do[t *= k;Print[t];If[k < 2, Continue[]];t += 2, {k, 5}]

Loop infinitely, until a condition is met:

Wolfram Language code: Do[If[k ^ 2 > 100, Return[k]], {k, ∞}]

Generalizations & Extensions (2)

Give a list of values to iterate over:

Wolfram Language code: Do[Print[k], {k, {a, b, c, d}}]

ParallelDo computes Do in parallel:

Wolfram Language code: ParallelDo[Print[i];i, {i, 4}]

Do can be parallelized automatically, effectively using ParallelDo:

Wolfram Language code: Parallelize[Do[Print[i];i, {i, 4}]]

Applications (5)

Generate a symbolic continued fraction:

Wolfram Language code: t = x;Do[t = 1 / (1 + t), {5}];t

Wolfram Language code: Nest[1 / (1 + #)&, x, 5]

Build up a list of primes:

Wolfram Language code: t = {};Do[If[PrimeQ[2 ^ n - 1], AppendTo[t, n]], {n, 100}];t

Alternatively use Reap and Sow:

Wolfram Language code: Reap[Do[If[PrimeQ[2 ^ n - 1], Sow[n]], {n, 100}]][[2, 1]]

Implement backsubstitution:

Wolfram Language code:

upperTriangularLinearSolve[ U_, v_ ]  := Module[ {x, m, n}, {m, n} = Dimensions[U]; x = Range[n];
	Do[x[[i]] = (v[[i]] - U[[i, i + 1 ;; n]].x[[i + 1 ;; n]]) / U[[i, i]], {i, n, 1, -1}];
	x];

Wolfram Language code: upperTriangularLinearSolve[{{1, 2}, {0, 3}}, {1, 2} ]

Implement LU triangular decomposition of matrices:

Wolfram Language code:

lu[A_] := 
	Module[{m, n, L, U}, {m, n} = Dimensions[A];L = IdentityMatrix[n];U = A;
	Do[
	L[[k ;; n, k]] = U[[k ;; n, k]] / U[[k, k]];
	U[[(k + 1) ;; n, k ;; n]] = U[[(k + 1) ;; n, k ;; n]] - L[[(k + 1) ;; n, {k}]].U[[{k}, k ;; n]];
	, {k, 1, n - 1}];
	{L, U}
	];

Wolfram Language code: {l, u} = lu[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}]

Wolfram Language code: l.u

The selection sort algorithm:

Wolfram Language code: list = RandomSample[Range[10], 10]

Wolfram Language code: Do[If[list[[i]] > list[[j]], list[[{i, j}]] = list[[{j, i}]]], {i, Length[list]}, {j, i + 1, Length[list]}];list