Class Combinatorics

Static class for combinatorics functions.

Inheritance

System.Object

Combinatorics

Namespace: ISynergy.Framework.Mathematics.Common

Assembly: ISynergy.Framework.Mathematics.dll

Syntax

public static class Combinatorics : object

Methods

Combinations<T>(T[], Boolean)

Enumerates all possible value combinations for a given array.

Declaration

public static IEnumerable<T[]> Combinations<T>(this T[] values, bool inPlace = false)

Parameters

Type	Name	Description
T[]	values	The array whose combinations need to be generated.
System.Boolean	inPlace	If set to true, the different generated combinations will be stored in the same array, thus preserving memory. However, this may prevent the samples from being stored in other locations without having to clone them. If set to false, a new memory block will be allocated for each new object in the sequence.

Returns

Type	Description
IEnumerable<T[]>

Type Parameters

Name	Description
T

Combinations<T>(T[], Int32, Boolean)

Enumerates all possible value combinations for a given array.

Declaration

public static IEnumerable<T[]> Combinations<T>(this T[] values, int k, bool inPlace = false)

Parameters

Type	Name	Description
T[]	values	The array whose combinations need to be generated.
System.Int32	k	The length of the combinations to be generated.
System.Boolean	inPlace	If set to true, the different generated combinations will be stored in the same array, thus preserving memory. However, this may prevent the samples from being stored in other locations without having to clone them. If set to false, a new memory block will be allocated for each new object in the sequence.

Returns

Type	Description
IEnumerable<T[]>

Type Parameters

Name	Description
T

Permutations<T>(T[], Boolean)

Enumerates all possible value permutations for a given array.

Declaration

public static IEnumerable<T[]> Permutations<T>(T[] values, bool inPlace = false)

Parameters

Type	Name	Description
T[]	values	The array whose permutations need to be generated
System.Boolean	inPlace	If set to true, the different generated permutations will be stored in the same array, thus preserving memory. However, this may prevent the samples from being stored in other locations without having to clone them. If set to false, a new memory block will be allocated for each new object in the sequence.

Returns

Type	Description
IEnumerable<T[]>

Type Parameters

Name	Description
T

Sequences(Int32, Boolean)

Provides a way to enumerate all possible ordered permutations with repetitions allowed (i.e. a truth table), without using many memory allocations.

Declaration

public static IEnumerable<int[]> Sequences(int length, bool inPlace = false)

Parameters

Type	Name	Description
System.Int32	length	The length of the sequence to generate.
System.Boolean	inPlace	If set to true, the different generated sequences will be stored in the same array, thus preserving memory. However, this may prevent the samples from being stored in other locations without having to clone them. If set to false, a new memory block will be allocated for each new object in the sequence.

Returns

Type	Description
IEnumerable<System.Int32[]>

Examples

Suppose we would like to generate the same sequences shown in the TruthTable(Int32, Int32)example, however, without explicitly storing all possible combinations in an array. In order to iterate over all possible combinations efficiently, we can use:

int length = 3;  // The number of variables; or number 
             // of columns in the generated table.
foreach (int[] row in Combinatorics.Sequences(length))
{
// The following sequences will be generated in order:
//
//   new int[] { 0, 0, 0 },
//   new int[] { 0, 0, 1 },
//   new int[] { 0, 1, 0 },
//   new int[] { 0, 1, 1 },
//   new int[] { 1, 0, 0 },
//   new int[] { 1, 0, 1 },
//   new int[] { 1, 1, 0 },
//   new int[] { 1, 1, 1 },
}

Sequences(Int32, Int32, Boolean)

Provides a way to enumerate all possible ordered permutations with repetitions allowed (i.e. a truth table), without using many memory allocations.

Declaration

public static IEnumerable<int[]> Sequences(int symbols, int length, bool inPlace = false)

Parameters

Type	Name	Description
System.Int32	symbols	The number of symbols.
System.Int32	length	The length of the sequence to generate.
System.Boolean	inPlace	If set to true, the different generated sequences will be stored in the same array, thus preserving memory. However, this may prevent the samples from being stored in other locations without having to clone them. If set to false, a new memory block will be allocated for each new object in the sequence.

Returns

Type	Description
IEnumerable<System.Int32[]>

Examples

Suppose we would like to generate the same sequences shown in the TruthTable(Int32, Int32)example, however, without explicitly storing all possible combinations in an array. In order to iterate over all possible combinations efficiently, we can use:

int symbols = 2; // Binary variables: either 0 or 1
int length = 3;  // The number of variables; or number 
             // of columns in the generated table.
foreach (int[] row in Combinatorics.Sequences(symbols, length))
{
// The following sequences will be generated in order:
//
//   new int[] { 0, 0, 0 },
//   new int[] { 0, 0, 1 },
//   new int[] { 0, 1, 0 },
//   new int[] { 0, 1, 1 },
//   new int[] { 1, 0, 0 },
//   new int[] { 1, 0, 1 },
//   new int[] { 1, 1, 0 },
//   new int[] { 1, 1, 1 },
}

Sequences(Int32[], Boolean, Boolean)

Provides a way to enumerate all possible ordered permutations with repetitions allowed (i.e. a truth table), without using many memory allocations.

Declaration

public static IEnumerable<int[]> Sequences(this int[] symbols, bool inPlace = false, bool firstColumnChangesFaster = false)

Parameters

Type	Name	Description
System.Int32[]	symbols	The number of symbols for each variable.
System.Boolean	inPlace	If set to true, the different generated permutations will be stored in the same array, thus preserving memory. However, this may prevent the samples from being stored in other locations without having to clone them. If set to false, a new memory block will be allocated for each new object in the sequence.
System.Boolean	firstColumnChangesFaster	If set to true, the first elements in the sequences will change faster than last ones. This changes the order in which the sequences are presented, but no their content.

Returns

Type	Description
IEnumerable<System.Int32[]>

Examples

Suppose we would like to generate the same sequences shown in the TruthTable(Int32, Int32)example, however, without explicitly storing all possible combinations in an array. In order to iterate over all possible combinations efficiently, we can use:

foreach (int[] row in Combinatorics.Sequences(new[] { 2, 2 }))
{
// The following sequences will be generated in order:
//
//   new int[] { 0, 0, 0 },
//   new int[] { 0, 0, 1 },
//   new int[] { 0, 1, 0 },
//   new int[] { 0, 1, 1 },
//   new int[] { 1, 0, 0 },
//   new int[] { 1, 0, 1 },
//   new int[] { 1, 1, 0 },
//   new int[] { 1, 1, 1 },
}

Subsets<T>(ISet<T>, Boolean)

Generates all possibles subsets of the given set.

Declaration

public static IEnumerable<SortedSet<T>> Subsets<T>(this ISet<T> set, bool inPlace = false)

Parameters

Type	Name	Description
ISet<T>	set
System.Boolean	inPlace

Returns

Type	Description
IEnumerable<SortedSet<T>>

Type Parameters

Name	Description
T

Subsets<T>(ISet<T>, Int32, Boolean)

Generates all possibles subsets of size k of the given set.

Declaration

public static IEnumerable<SortedSet<T>> Subsets<T>(this ISet<T> set, int k, bool inPlace = false)

Parameters

Type	Name	Description
ISet<T>	set
System.Int32	k
System.Boolean	inPlace

Returns

Type	Description
IEnumerable<SortedSet<T>>

Type Parameters

Name	Description
T

TruthTable(Int32)

Generates all possible two symbol ordered permutations with repetitions allowed (a truth table).

Declaration

public static int[][] TruthTable(int length)

Parameters

Type	Name	Description
System.Int32	length	The length of the sequence to generate.

Returns

Type	Description
System.Int32[][]

Examples

Suppose we would like to generate a truth table for a binary problem. In this case, we are only interested in two symbols: 0 and 1. Let's then generate the table for three binary values

int length = 3;  // The number of variables; or number 
             // of columns in the generated table.
// Generate the table using Combinatorics.TruthTable(3)
int[][] table = Combinatorics.TruthTable(length);
// The generated table will be:
{
new int[] { 0, 0, 0 },
new int[] { 0, 0, 1 },
new int[] { 0, 1, 0 },
new int[] { 0, 1, 1 },
new int[] { 1, 0, 0 },
new int[] { 1, 0, 1 },
new int[] { 1, 1, 0 },
new int[] { 1, 1, 1 },
};

TruthTable(Int32, Int32)

Generates all possible ordered permutations with repetitions allowed (a truth table).

Declaration

public static int[][] TruthTable(int symbols, int length)

Parameters

Type	Name	Description
System.Int32	symbols	The number of symbols.
System.Int32	length	The length of the sequence to generate.

Returns

Type	Description
System.Int32[][]

Examples

Suppose we would like to generate a truth table for a binary problem. In this case, we are only interested in two symbols: 0 and 1. Let's then generate the table for three binary values

int symbols = 2; // Binary variables: either 0 or 1
int length = 3;  // The number of variables; or number 
             // of columns in the generated table.
// Generate the table using Combinatorics.TruthTable(2,3)
int[][] table = Combinatorics.TruthTable(symbols, length);
// The generated table will be:
{
new int[] { 0, 0, 0 },
new int[] { 0, 0, 1 },
new int[] { 0, 1, 0 },
new int[] { 0, 1, 1 },
new int[] { 1, 0, 0 },
new int[] { 1, 0, 1 },
new int[] { 1, 1, 0 },
new int[] { 1, 1, 1 },
};

See Also

Sequences(Int32, Int32, Boolean)

TruthTable(Int32[])

Generates all possible ordered permutations with repetitions allowed (a truth table).

Declaration

public static int[][] TruthTable(this int[] symbols)

Parameters

Type	Name	Description
System.Int32[]	symbols	The number of symbols for each variable.

Returns

Type	Description
System.Int32[][]

Examples

Suppose we would like to generate a truth table (i.e. all possible combinations of a set of discrete symbols) for variables that contain different numbers symbols. Let's say, for example, that the first variable may contain symbols 0 and 1, the second could contain either 0, 1, or 2, and the last one again could contain only 0 and 1. Thus we can generate the truth table in the following way:

// Number of symbols for each variable
int[] symbols = { 2, 3, 2 };
// Generate the truth table for the given symbols
int[][] table = Combinatorics.TruthTable(symbols);
// The generated table will be:
{
new int[] { 0, 0, 0 },
new int[] { 0, 0, 1 },
new int[] { 0, 1, 0 },
new int[] { 0, 1, 1 },
new int[] { 0, 2, 0 },
new int[] { 0, 2, 1 },
new int[] { 1, 0, 0 },
new int[] { 1, 0, 1 },
new int[] { 1, 1, 0 },
new int[] { 1, 1, 1 },
new int[] { 1, 2, 0 },
new int[] { 1, 2, 1 },
};

See Also

Sequences(Int32, Int32, Boolean)