cartesianProduct

Lazily computes the Cartesian product of two or more ranges. The product is a range of tuples of elements from each respective range.

The conditions for the two-range case are as follows:

If both ranges are finite, then one must be (at least) a forward range and the other an input range.

If one range is infinite and the other finite, then the finite range must be a forward range, and the infinite range can be an input range.

If both ranges are infinite, then both must be forward ranges.

When there are more than two ranges, the above conditions apply to each adjacent pair of ranges.

auto cartesianProduct(R1 range1, R2 range2)
auto
cartesianProduct
(
R1
R2
)
(
R1 range1
,
R2 range2
)
if (
!allSatisfy!(isForwardRange, R1, R2) ||
anySatisfy!(isInfinite, R1, R2)
)
auto cartesianProduct(RR ranges)
auto cartesianProduct(R1 range1, R2 range2, RR otherRanges)

Parameters

range1 R1: The first range
range2 R2: The second range

Return Value

Type: auto

A forward range of std.typecons.Tuple representing elements of the cartesian product of the given ranges.

Examples

import std.algorithm.searching : canFind;
import std.range;
import std.typecons : tuple;

auto N = sequence!"n"(0);         // the range of natural numbers
auto N2 = cartesianProduct(N, N); // the range of all pairs of natural numbers

// Various arbitrary number pairs can be found in the range in finite time.
assert(canFind(N2, tuple(0, 0)));
assert(canFind(N2, tuple(123, 321)));
assert(canFind(N2, tuple(11, 35)));
assert(canFind(N2, tuple(279, 172)));

import std.algorithm.searching : canFind;
import std.typecons : tuple;

auto B = [ 1, 2, 3 ];
auto C = [ 4, 5, 6 ];
auto BC = cartesianProduct(B, C);

foreach (n; [[1, 4], [2, 4], [3, 4], [1, 5], [2, 5], [3, 5], [1, 6],
             [2, 6], [3, 6]])
{
    assert(canFind(BC, tuple(n[0], n[1])));
}

1 import std.algorithm.comparison : equal;
2 import std.typecons : tuple;
3 
4 auto A = [ 1, 2, 3 ];
5 auto B = [ 'a', 'b', 'c' ];
6 auto C = [ "x", "y", "z" ];
7 auto ABC = cartesianProduct(A, B, C);
8 
9 assert(ABC.equal([
10     tuple(1, 'a', "x"), tuple(1, 'a', "y"), tuple(1, 'a', "z"),
11     tuple(1, 'b', "x"), tuple(1, 'b', "y"), tuple(1, 'b', "z"),
12     tuple(1, 'c', "x"), tuple(1, 'c', "y"), tuple(1, 'c', "z"),
13     tuple(2, 'a', "x"), tuple(2, 'a', "y"), tuple(2, 'a', "z"),
14     tuple(2, 'b', "x"), tuple(2, 'b', "y"), tuple(2, 'b', "z"),
15     tuple(2, 'c', "x"), tuple(2, 'c', "y"), tuple(2, 'c', "z"),
16     tuple(3, 'a', "x"), tuple(3, 'a', "y"), tuple(3, 'a', "z"),
17     tuple(3, 'b', "x"), tuple(3, 'b', "y"), tuple(3, 'b', "z"),
18     tuple(3, 'c', "x"), tuple(3, 'c', "y"), tuple(3, 'c', "z")
19 ]));

cartesianProduct

Parameters

Return Value

Examples

Meta

Source