dpaukov / combinatoricslib

Combinatorial Objects Generators for Java 7+.

combinatoricslib 2.4

Very simple java library to generate permutations, combinations and other combinatorial sequences for Java 7+. New version of the library for (Java 8) can be found here.

1. Simple combinations
2. Combinations with repetitions (multicombination)
3. Simple permutations
4. Permutations with repetitions
5. Subsets
6. Integer Partitions
7. List Partitions
8. Integer Compositions
9. Cartesian Product
10. The latest release

You can use the following table to select a generator:

Description	Is Order Important?	Is Repetition Allowed?	CombinatoricsFactory Method
Simple combinations	No	No	createSimpleCombinationGenerator()
Combinations with repetitions	No	Yes	createMultiCombinationGenerator()
Simple permutations	Yes	No	createPermutationGenerator()
Permutations with repetitions	Yes	Yes	createPermutationWithRepetitionGenerator()

1. Simple combinations

A simple k-combination of a finite set S is a subset of k distinct elements of S. Specifying a subset does not arrange them in a particular order. As an example, a poker hand can be described as a 5-combination of cards from a 52-card deck: the 5 cards of the hand are all distinct, and the order of the cards in the hand does not matter.

Let's generate all 3-combination of the set of 5 colors (red, black, white, green, blue).

   ICombinatoricsVector<String> vector = createVector("red", "black", "white", "green", "blue");
   Generator<String> gen = createSimpleCombinationGenerator(vector, 3);
   for (ICombinatoricsVector<String> combination : gen) {
      System.out.println(combination);
   }

And the result of 10 combinations

   CombinatoricsVector=([red, black, white], size=3)
   CombinatoricsVector=([red, black, green], size=3)
   CombinatoricsVector=([red, black, blue], size=3)
   CombinatoricsVector=([red, white, green], size=3)
   CombinatoricsVector=([red, white, blue], size=3)
   CombinatoricsVector=([red, green, blue], size=3)
   CombinatoricsVector=([black, white, green], size=3)
   CombinatoricsVector=([black, white, blue], size=3)
   CombinatoricsVector=([black, green, blue], size=3)
   CombinatoricsVector=([white, green, blue], size=3)

2. Combinations with repetitions

A k-multicombination or k-combination with repetition of a finite set S is given by a sequence of k not necessarily distinct elements of S, where order is not taken into account.

As an example. Suppose there are 2 types of fruits (apple and orange) at a grocery store, and you want to buy 3 pieces of fruit. You could select

• (apple, apple, apple)
• (apple, apple, orange)
• (apple, orange, orange)
• (orange, orange, orange)

Let's generate all 3-combinations with repetitions of the set (apple, orange).

   ICombinatoricsVector<String> vector = createVector("apple", "orange");
   Generator<String> gen = createMultiCombinationGenerator(vector, 3);
   for (ICombinatoricsVector<String> combination : gen) {
      System.out.println(combination);
   }

And the result of 4 multi-combinations

   CombinatoricsVector=([apple, apple, apple], size=3)
   CombinatoricsVector=([apple, apple, orange], size=3)
   CombinatoricsVector=([apple, orange, orange], size=3)
   CombinatoricsVector=([orange, orange, orange], size=3)

3. Simple permutations

A permutation is an ordering of a set in the context of all possible orderings. For example, the set containing the first three digits, 123, has six permutations: 123, 132, 213, 231, 312, and 321.

This is an example of the permutations of 3 (apple, orange, cherry):

   ICombinatoricsVector<String> vector = CombinatoricsFactory.createVector("apple", "orange", "cherry");
   Generator<String> gen = createPermutationGenerator(vector);
   for (ICombinatoricsVector<String> perm : gen) {
      System.out.println(perm);
   }

All possible permutations:

   CombinatoricsVector=([apple, orange, cherry], size=3)
   CombinatoricsVector=([apple, cherry, orange], size=3)
   CombinatoricsVector=([cherry, apple, orange], size=3)
   CombinatoricsVector=([cherry, orange, apple], size=3)
   CombinatoricsVector=([orange, cherry, apple], size=3)
   CombinatoricsVector=([orange, apple, cherry], size=3)

The generator can produce the permutations even if the initial vector has duplicates. For example, all permutations of (1,1,2,2) are:

   ICombinatoricsVector<Integer> vector = createVector(1, 1, 2, 2);
   Generator<Integer> generator = createPermutationGenerator(vector);
   for (ICombinatoricsVector<Integer> perm : generator) {
      System.out.println(perm);
   }

The result of all possible permutations

   CombinatoricsVector=([1, 1, 2, 2], size=4)
   CombinatoricsVector=([1, 2, 1, 2], size=4)
   CombinatoricsVector=([1, 2, 2, 1], size=4)
   CombinatoricsVector=([2, 1, 1, 2], size=4)
   CombinatoricsVector=([2, 1, 2, 1], size=4)
   CombinatoricsVector=([2, 2, 1, 1], size=4)

4. Permutations with repetitions

The permutation may have more elements than slots. For example, all possible permutation of '12' in three slots are: 111, 211, 121, 221, 112, 212, 122, and 222.

Let's generate all possible permutations with repetitions of 3 elements from the set of apple and orange.

   // Create an initial vector of 2 elements (apple, orange)
   ICombinatoricsVector<String> vector = createVector("apple", "orange");
   Generator<String> gen = createPermutationWithRepetitionGenerator(vector, 3);
   for (ICombinatoricsVector<String> perm : gen) {
      System.out.println( perm );
   }

And the result of 8 permutations

   CombinatoricsVector=([apple, apple, apple], size=3)
   CombinatoricsVector=([orange, apple, apple], size=3)
   CombinatoricsVector=([apple, orange, apple], size=3)
   CombinatoricsVector=([orange, orange, apple], size=3)
   CombinatoricsVector=([apple, apple, orange], size=3)
   CombinatoricsVector=([orange, apple, orange], size=3)
   CombinatoricsVector=([apple, orange, orange], size=3)
   CombinatoricsVector=([orange, orange, orange], size=3)

5. Subsets

A set A is a subset of a set B if A is "contained" inside B. A and B may coincide. The relationship of one set being a subset of another is called inclusion or sometimes containment.

Examples:

The set (1, 2) is a proper subset of (1, 2, 3). Any set is a subset of itself, but not a proper subset. The empty set, denoted by ∅, is also a subset of any given set X. All subsets of (1, 2, 3) are:

• ()
• (1)
• (2)
• (1, 2)
• (3)
• (1, 3)
• (2, 3)
• (1, 2, 3)

And code which generates all subsets of (one, two, three)

   ICombinatoricsVector<String> set = createVector( "one", "two", "three");
   Generator<String> gen = createSubSetGenerator(set);
   for (ICombinatoricsVector<String> subSet : gen) {
      System.out.println(subSet);
   }

And the result of all possible 8 subsets

   CombinatoricsVector=([], size=0)
   CombinatoricsVector=([one], size=1)
   CombinatoricsVector=([two], size=1)
   CombinatoricsVector=([one, two], size=2)
   CombinatoricsVector=([three], size=1)
   CombinatoricsVector=([one, three], size=2)
   CombinatoricsVector=([two, three], size=2)
   CombinatoricsVector=([one, two, three], size=3)

6. Integer Partitions

In number theory, a partition of a positive integer n is a way of writing n as a sum of positive integers. Two sums that differ only in the order of their summands are considered to be the same partition; if order matters then the sum becomes a composition. A summand in a partition is also called a part.

The partitions of 5 are listed below:

• 1 + 1 + 1 + 1 + 1
• 2 + 1 + 1 + 1
• 2 + 2 + 1
• 3 + 1 + 1
• 3 + 2
• 4 + 1
• 5

The number of partitions of n is given by the partition function p(n). In number theory, the partition function p(n) represents the number of possible partitions of a natural number n, which is to say the number of distinct (and order independent) ways of representing n as a sum of natural numbers.

Let's generate all possible partitions of 5:

   Generator<Integer> partitions = createPartitionGenerator(5);
   for (ICombinatoricsVector<Integer> p : partitions) {
      System.out.println(p);
   }

And the result of all 7 integer possible partitions

   CombinatoricsVector=([1, 1, 1, 1, 1], size=5)
   CombinatoricsVector=([2, 1, 1, 1], size=4)
   CombinatoricsVector=([2, 2, 1], size=3)
   CombinatoricsVector=([3, 1, 1], size=3)
   CombinatoricsVector=([3, 2], size=2)
   CombinatoricsVector=([4, 1], size=2)
   CombinatoricsVector=([5], size=1)

7. List Partitions

It is possible to generate non-overlapping sublists of length n of a given list

For example, if a list is (A, B, B, C), then the non-overlapping sublists of length 2 will be:

• ( (A), (B, B, C) )
• ( (B, B, C), (A) )
• ( (B), (A, B, C) )
• ( (A, B, C), (B) )
• ( (A, B), (B, C) )
• ( (B, C), (A, B) )
• ( (B, B), (A, C) )
• ( (A, C), (B, B) )
• ( (A, B, B), (C) )
• ( (C), (A, B, B) )

To do that you should use an instance of the complex combination generator

   ICombinatoricsVector<String> vector = createVector "A", "B", "B", "C");
   Generator<ICombinatoricsVector<String>> gen = new ComplexCombinationGenerator<String>(vector, 2);
   for (ICombinatoricsVector<ICombinatoricsVector<String>> comb : gen) {
      System.out.println(convert2String(comb) + " - " + comb);
   }

And the result

   ([A],[B, B, C]) - CombinatoricsVector=([CombinatoricsVector=([A], size=1), CombinatoricsVector=([B, B, C], size=3)], size=2)
   ([B, B, C],[A]) - CombinatoricsVector=([CombinatoricsVector=([B, B, C], size=3), CombinatoricsVector=([A], size=1)], size=2)
   ([B],[A, B, C]) - CombinatoricsVector=([CombinatoricsVector=([B], size=1), CombinatoricsVector=([A, B, C], size=3)], size=2)
   ([A, B, C],[B]) - CombinatoricsVector=([CombinatoricsVector=([A, B, C], size=3), CombinatoricsVector=([B], size=1)], size=2)
   ([A, B],[B, C]) - CombinatoricsVector=([CombinatoricsVector=([A, B], size=2), CombinatoricsVector=([B, C], size=2)], size=2)
   ([B, C],[A, B]) - CombinatoricsVector=([CombinatoricsVector=([B, C], size=2), CombinatoricsVector=([A, B], size=2)], size=2)
   ([B, B],[A, C]) - CombinatoricsVector=([CombinatoricsVector=([B, B], size=2), CombinatoricsVector=([A, C], size=2)], size=2)
   ([A, C],[B, B]) - CombinatoricsVector=([CombinatoricsVector=([A, C], size=2), CombinatoricsVector=([B, B], size=2)], size=2)
   ([A, B, B],[C]) - CombinatoricsVector=([CombinatoricsVector=([A, B, B], size=3), CombinatoricsVector=([C], size=1)], size=2)
   ([C],[A, B, B]) - CombinatoricsVector=([CombinatoricsVector=([C], size=1), CombinatoricsVector=([A, B, B], size=3)], size=2)

8. Integer Compositions

A composition of an integer n is a way of writing n as the sum of a sequence of (strictly) positive integers. Two sequences that differ in the order of their terms define different compositions of their sum, while they are considered to define the same partition of that number (see. Integer Partitions above).

The 16 compositions of 5 are:

• 5
• 4+1
• 3+2
• 3+1+1
• 2+3
• 2+2+1
• 2+1+2
• 2+1+1+1
• 1+4
• 1+3+1
• 1+2+2
• 1+2+1+1
• 1+1+3
• 1+1+2+1
• 1+1+1+2
• 1+1+1+1+1.

Compare this with the seven partitions of 5 (see Integer Partitions above):

• 5
• 4+1
• 3+2
• 3+1+1
• 2+2+1
• 2+1+1+1
• 1+1+1+1+1.

Example. Generate all possible integer compositions of 5.

   // Create an instance of the integer composition generator to generate all possible compositions of 5
   Generator<Integer> gen = createCompositionGenerator(5);
   for (ICombinatoricsVector<Integer> p : gen) {
      System.out.println(p);
   }

And the result

   CombinatoricsVector=([5], size=1)
   CombinatoricsVector=([1, 4], size=2)
   CombinatoricsVector=([2, 3], size=2)
   CombinatoricsVector=([1, 1, 3], size=3)
   CombinatoricsVector=([3, 2], size=2)
   CombinatoricsVector=([1, 2, 2], size=3)
   CombinatoricsVector=([2, 1, 2], size=3)
   CombinatoricsVector=([1, 1, 1, 2], size=4)
   CombinatoricsVector=([4, 1], size=2)
   CombinatoricsVector=([1, 3, 1], size=3)
   CombinatoricsVector=([2, 2, 1], size=3)
   CombinatoricsVector=([1, 1, 2, 1], size=4)
   CombinatoricsVector=([3, 1, 1], size=3)
   CombinatoricsVector=([1, 2, 1, 1], size=4)
   CombinatoricsVector=([2, 1, 1, 1], size=4)
   CombinatoricsVector=([1, 1, 1, 1, 1], size=5)

9. Cartesian Product

This generator generates Cartesian product from a number of lists. Set of lists is specified in the constructor of generator to generate k-element Cartesian product, where k is the size of the set of lists.

A simple k-element Cartesian product of a finite sets S(1), S(2)...S(k) is a set of all ordered pairs (x(1), x(2)...x(k), where x(1) ∈ S(1), x(2) ∈ S(2) ... x(k) ∈ S(k)

Example. Generate the cartesian product for (1, 2), (4), (5, 6).

   ICombinatoricsVector<Integer> set01 = createVector(1, 2);
   ICombinatoricsVector<Integer> set02 = createVector(4);
   ICombinatoricsVector<Integer> set03 = createVector(5, 6);

   Generator<Integer> generator = createCartesianProductGenerator(set01, set02, set03);
   for (ICombinatoricsVector<Integer> catresianProduct : generator) {
      System.out.println(catresianProduct);
   }

The cartesian product will be:

   CombinatoricsVector=([1, 4, 5], size=3)
   CombinatoricsVector=([1, 4, 6], size=3)
   CombinatoricsVector=([2, 4, 5], size=3)
   CombinatoricsVector=([2, 4, 6], size=3)

The latest stable release - version 2.3

The latest release of the library is available through The Maven Central Repository here. Include the following section into your pom.xml file.

<dependency>
  <groupId>com.googlecode.combinatoricslib</groupId>
  <artifactId>combinatoricslib</artifactId>
  <version>2.3</version>
  <scope>compile</scope>
</dependency>

combinatoricslib's Issues

Use the Visistor pattern for ComplexCombinationIterator to avoid unnecessary creation of objects

Suppose you would like to analyze the combinations only until you have found a "match" and then stop the iteration.
Wouldn't it be better to use the Visitor pattern for each generated combination to avoid the creation of all combinations in ComplexCombinationIterator#init() method for the iterator in the _resultSet variable?
See: https://en.wikipedia.org/wiki/Visitor_pattern

The Simple combinations generator does not return other then {0,1,2,3} when asked to make combinations with those numbers

From [email protected] on January 10, 2013 05:06:12

When i enter {0,1,2,3], it only returns that, and not f.ex {3,1,2,0}

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=7

Friendly suggestion: Combinations with Repetition

From tcarolan on November 23, 2011 00:03:40

Might you consider adding combinations with repetition to your library? Seems a logical next step. Thanks for the great open source contribution.

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=2

Need method to randomly sample SimpleCombination

From PeterVermont on December 21, 2012 18:00:55

I would email but don't know your email address.

I am the main developer for MDR - Multifactor Dimensionality Reduction which is a fairly simple classifier used in bioinformatics. See http://sourceforge.net/projects/mdr/ Normally, users do an exhaustive search over attribute combinations but we also have a random timed mode. Currently I make no effort from to prevent the random from testing the same combination more than once. I would like a tool that would allow me to get combinations without replacement. The issue is that it must be extremely efficient and fast -- it is not worthwhile to just maintain a list of tested combinations. It would be okay and perhaps even preferable if the progression were 'psuedo-random' in such a way that all attributes were tested fairly equally.

Another related, but harder problem, is using evolutionary algorithms to test combinations. I have found that this tends to test the same combinations many many times, since I already use elitism so I don't lose track of winners, this is a big waste of processing time. If I had a good way to know what has been sampled previously I could prevent waste -- this would also act as a form of 'novelty' seeking which has been shown in some evolutionary algorithm contexts to be helpful.

Thanks,

Peter Andrews
Norich, Vermont USA

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=6

Publish to a public maven repo.

From [email protected] on November 18, 2012 04:44:58

Would be nice to publish release into a public maven repository.

Regards,

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=4

Maven Central Repo is weird

From [email protected] on November 12, 2013 18:31:12

URL : http://search.maven.org/#artifactdetails%7Ccom.googlecode.combinatoricslib%7Ccombinatoricslib%7C2.0%7Cjar See screenshot.

combinatoricslib
versus
combinatoricsLib

Attachment: combini-01.png

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=8

For ComplexCombinationGenerator add "number of elements in every group"

Reported by [email protected], Feb 23, 2015
For the ComplexCombinationGenerator it should not only be possible to specify the number of groups, but also the number of elements in every group. E.g. searching for [1, 2, 3, 4, 5, 6] only searching for groups of length 3 should output:

[1] 1 3 5
[2] 2 4 6

[1] 1 3 4
[2] 2 5 6

[1] 1 3 4
[2] 2 6 5

[1] 1 2 5
[2] 3 4 6

[1] 1 2 4
[2] 3 5 6

[1] 1 2 4
[2] 3 6 5

[1] 1 2 5
[2] 4 3 6

[1] 1 2 3
[2] 4 5 6

[1] 1 2 3
[2] 4 6 5

[1] 1 2 4
[2] 5 3 6

[1] 1 2 3
[2] 5 4 6

[1] 1 2 3
[2] 5 6 4

[1] 1 2 4
[2] 6 3 5

[1] 1 2 3
[2] 6 4 5

[1] 1 2 3
[2] 6 5 4

Generating all the items and using an IFilter is very slow. Taking the length of the sub lists into concideration should speed up the generation a lot. Please see an algorithm in R as reference: http://stackoverflow.com/a/14758057

Thanks & regards, Kristian

License Missing

From the old site, I got the impression that this library is covered under the GNU Lesser GPL. Can I work under this impression?

Runtime exception in getNumberOfGeneratedObjects when using createPermutationGenerator with treatAsIdentical=false

From [email protected] on March 08, 2014 11:17:56

What steps will reproduce the problem? I run the following code:
org.paukov.combinatorics.ICombinatoricsVector originalVector =
org.paukov.combinatorics.Factory.createVector(new String[]{"apple","orange", "apple", "orange"});
org.paukov.combinatorics.Generator permutations =
org.paukov.combinatorics.Factory.createPermutationGenerator(
originalVector,false);
System.out.println("size "+permutations.getNumberOfGeneratedObjects());
for (org.paukov.combinatorics.ICombinatoricsVector permutation : permutations)
{
System.out.println(permutation.toString());
} What is the expected output? What do you see instead? An exception occurred during evaluation: java.lang.RuntimeException
But if I remove the first println with the getNumberOfGeneratedObjects()

the output is ok:
CombinatoricsVector=([apple, apple, orange, orange], size=4)
CombinatoricsVector=([apple, orange, apple, orange], size=4)
CombinatoricsVector=([apple, orange, orange, apple], size=4)
CombinatoricsVector=([orange, apple, apple, orange], size=4)
CombinatoricsVector=([orange, apple, orange, apple], size=4)
CombinatoricsVector=([orange, orange, apple, apple], size=4) What version of the product are you using? On what operating system? it was on r174 v2.1 in eclipse kepler sp1 scrapbook with java 1.7_51 on win7

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=9

Name of Factory class should change

Reported by martin.kamleithner, Feb 23, 2015

"Factory" is a very generic name, it clashes with other libraries, so programmers have to specify the whole path. In my opinion, something like "CombinatoricsFactory" would be better.

getNumberOfGeneratedObjects() returns long; ints only accepted by generateObjectsRange()

Reported by glparsons, 16 Apr 2015
What steps will reproduce the problem.

1. Go to documentation: https://combinatoricslib.googlecode.com/svn/tags/release21/doc/org/paukov/combinatorics/IGenerator.html#generateObjectsRange(int, int)
2. Subject line says the rest. What happens if the number of objects is greater than an int...and you need to access a latter sub-range with indices of size greater than an int (long, as returned by getNumberOfGeneratedObjects())?

Am I missing something?

Thanks.
Greg

Change factorial function in `combination`

Hi @dpaukov ,

I've been using this version of the library and an issue arose, which I believe is minimal work to correct, so here it is:

I use the getNumberOfGeneratedObjects function which uses the simple factorial and not the one with the BigDecimal type, so when in my application I happened to use in the combination(n,k), n=21 and k=0 respectively, it return zero for the denominator. (factorial(21) > max Long).

If instead the Util.combination(n,k) function was using the BigDecimal factorial, and only after the calculation it converted to long type, that would an easy and satisfiable fix for me (^-^)

Treat repeated elements of sinple permutation as identical

From [email protected] on September 21, 2012 15:45:57

What steps will reproduce the problem? ICombinatoricsVector corePermutation = Factory.createVector(new Integer[]{1, 2, 2, 3});

Generator generator = Factory.createPermutationGenerator(corePermutation);

Map<List,Character> seenVectors = new HashMap<List, Character>();
Character ch = 'A';
for (ICombinatoricsVector perm : generator) {
List vector = perm.getVector();
String repeatStr = " -- "+ch;
if(seenVectors.containsKey(vector))
repeatStr = " -- Repeated "+seenVectors.get(vector);
else
seenVectors.put(vector, ch++);
System.out.println(perm+repeatStr);
} What is the expected output? What do you see instead? CombinatoricsVector=([1, 2, 2, 3], size=4) -- A
CombinatoricsVector=([1, 2, 3, 2], size=4) -- B
CombinatoricsVector=([1, 3, 2, 2], size=4) -- C
CombinatoricsVector=([3, 1, 2, 2], size=4) -- D
CombinatoricsVector=([3, 1, 2, 2], size=4) -- Repeated D
CombinatoricsVector=([1, 3, 2, 2], size=4) -- Repeated C
CombinatoricsVector=([1, 2, 3, 2], size=4) -- Repeated B
CombinatoricsVector=([1, 2, 2, 3], size=4) -- Repeated A
CombinatoricsVector=([2, 1, 2, 3], size=4) -- E
CombinatoricsVector=([2, 1, 3, 2], size=4) -- F
CombinatoricsVector=([2, 3, 1, 2], size=4) -- G
CombinatoricsVector=([3, 2, 1, 2], size=4) -- H
CombinatoricsVector=([3, 2, 2, 1], size=4) -- I
CombinatoricsVector=([2, 3, 2, 1], size=4) -- J
CombinatoricsVector=([2, 2, 3, 1], size=4) -- K
CombinatoricsVector=([2, 2, 1, 3], size=4) -- L
CombinatoricsVector=([2, 2, 1, 3], size=4) -- Repeated L
CombinatoricsVector=([2, 2, 3, 1], size=4) -- Repeated K
CombinatoricsVector=([2, 3, 2, 1], size=4) -- Repeated J
CombinatoricsVector=([3, 2, 2, 1], size=4) -- Repeated I
CombinatoricsVector=([3, 2, 1, 2], size=4) -- Repeated H
CombinatoricsVector=([2, 3, 1, 2], size=4) -- Repeated G
CombinatoricsVector=([2, 1, 3, 2], size=4) -- Repeated F
CombinatoricsVector=([2, 1, 2, 3], size=4) -- Repeated E

All repeated permutations have to be removed

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=3

Compositions

From [email protected] on June 14, 2010 10:42:59

Hello,

I am wondering if you have any plans of adding compositions to the combinatoricslib library ?

Compositions are partitions where the order is significant. Eg: 5 has 7 partitions and 16 compositions. http://en.wikipedia.org/wiki/Composition_(number_theory) Thank you for reading,
Matt C.

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=1

Add List#addAll(int index, Collection c) based Factory method

In CombinatoricsVector

    public CombinatoricsVector(int index, Collection<? extends T> vector) {
        _vector = new ArrayList<T>(vector.size()-index);
        _vector.addAll(index, vector);
    }

In Factory

    public static <T> ICombinatoricsVector<T> createVector(int index,
            Collection<? extends T> collection) {
        return new CombinatoricsVector<T>(index, collection);
    }

Using an iterator rather than a vector?

From PeterVermont on December 19, 2012 23:40:45

I would like the equivalent of the Python itertools.combinations(iterable, r)

See: http://docs.python.org/2/library/itertools.html#itertools.combinations I wish to make a SimpleCombination of Integers over a range. As best as I can tell, all of your code requires generating a vector the size of the entire range which could be hundreds of thousands.

Thanks!

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=5

factorial function should change

From [email protected] on March 13, 2014 05:05:11

factorial must change to ==>

public static BigDecimal factorial(long x) {
BigDecimal result = BigDecimal.valueOf(1);
for (long i = 2; i <= x; i++) {
result=result.multiply(BigDecimal.valueOf(i));
}
return result;
}

becos is x is big enough,result will bigger than Long.maxVal()

Original issue: http://code.google.com/p/combinatoricslib/issues/detail?id=10

permutation without repetition with selected object r from n things

is it possible to do permutation without repetition with selected objects r ?
P(n , r) = n! / (n - r)!

where n is the number of things to choose from, and we choose r of them
Is there any API doc available for the library?