BGC.Mathematics.Combinatorics Class Reference

Static Public Member Functions
static void	TreeOfAllCombinations (int[] indexes, int outputSize, out Node< int > root)
	Build a tree of all combinations. More...
static List< List< int > >	ListOfAllCombinations (Node< int > root)
	Given a list of indexes, generate a list of all valid combinations. More...
static IEnumerator< List< int > >	AllCombinationsGenerator (int[] indexes, int outputSize)
	Generate a list of indexes one at a time, generate a list of all valid combinations. More...

Static Private Member Functions
static List< List< int > >	ListOfAllCombinationsRecursive (Node< int > node)

Detailed Description

Definition at line 7 of file Combinatorics.cs.

Member Function Documentation

AllCombinationsGenerator()

static IEnumerator<List<int> > BGC.Mathematics.Combinatorics.AllCombinationsGenerator ( int []  indexes, int  outputSize  )

inlinestatic

Generate a list of indexes one at a time, generate a list of all valid combinations.

For example: ([0,1], 2) will return [[0, 0], [0, 1], [1, 0], [1, 1]]

Where the second number in the input defines the size of the inner. Additionally, the ordering of these will be randomized.

Todo:

: needs to generate one at a time rather than use the list method that is provided arrays.

Definition at line 92 of file Combinatorics.cs.

        {
            Node<int> root;
            TreeOfAllCombinations(indexes, outputSize, out root);
            List<List<int>> combinations = ListOfAllCombinations(root);

            for (int i = 0; i < combinations.Count; ++i)
            {
                yield return combinations[i];
            }
        }

ListOfAllCombinations()

static List<List<int> > BGC.Mathematics.Combinatorics.ListOfAllCombinations ( Node< int >  root )

inlinestatic

Given a list of indexes, generate a list of all valid combinations.

For example: ([0,1], 2) will return [[0, 0], [0, 1], [1, 0], [1, 1]]

Where the second number in the input defines the size of the inner. Additionally, the ordering of these will be randomized. arrays.

Definition at line 59 of file Combinatorics.cs.

References BGC.DataStructures.Generic.Node< T >.Children.

        {
            List<List<int>> output = new List<List<int>>();

            for (int i = 0; i < root.Children.Count; ++i)
            {
                List<List<int>> childOutput = ListOfAllCombinationsRecursive(root.Children[i]);

                for (int j = 0; j < childOutput.Count; ++j)
                {
                    output.Add(childOutput[j]);
                }
            }

            return output;
        }

ListOfAllCombinationsRecursive()

static List<List<int> > BGC.Mathematics.Combinatorics.ListOfAllCombinationsRecursive ( Node< int >  node )

inlinestaticprivate

Definition at line 104 of file Combinatorics.cs.

References BGC.DataStructures.Generic.Node< T >.Children, and BGC.DataStructures.Generic.Node< T >.Value.

        {
            List<List<int>> output = new List<List<int>>();
            if (node.Children.Count <= 0)
            {
                output.Add(new List<int>() { node.Value });
                return output;
            }

            for (int i = 0; i < node.Children.Count; ++i)
            {
                List<List<int>> childOutput = ListOfAllCombinationsRecursive(node.Children[i]);

                for (int j = 0; j < childOutput.Count; ++j)
                {
                    childOutput[j].Add(node.Value);
                    output.Add(childOutput[j]);
                }
            }

            return output;
        }

TreeOfAllCombinations()

static void BGC.Mathematics.Combinatorics.TreeOfAllCombinations ( int []  indexes, int  outputSize, out Node< int >  root  )

inlinestatic

Build a tree of all combinations.

For example: ([0, 1], 2) would generate a tree of structure -1 |-0 | |-0 | |-1 | |-1 |-0 |-1

Except for the fact that the ordering will be randomized.

Definition at line 24 of file Combinatorics.cs.

        {
            root = new Node<int>(-1);

            if (outputSize <= 0)
            {
                return;
            }
            
            int[] copyIndexes = new int[indexes.Length];
            System.Array.Copy(indexes, copyIndexes, indexes.Length);
            copyIndexes.Shuffle();

            for (int i = 0; i < indexes.Length; ++i)
            { 
                Node<int> child;
                TreeOfAllCombinations(indexes, outputSize - 1, out child);
                child.Value = copyIndexes[i];
                root.Children.Add(child);
            }
        }

---

The documentation for this class was generated from the following file:

• Mathematics/Combinatorics.cs