This method tries to find the best decomposition, that means the list of patterns with minimal summary number of points. For good pattern, the returned patterns list can consist of O(log2N) points (sum of {@link #pointCount()}values for all returned patterns), where N is the number of points ( {@link #pointCount()}) in this pattern. For example, a linear one-dimensional segment {x: 0<=x<2m} is a Minkowski sum of m point pairs {0, 2i}, i=0,1,...,m-1.
There is no guarantee that this method returns a good decomposition. If this method cannot find required decomposition, it returns the 1-element list containing this instance as the only element.
If the number of points in this pattern is less than the argument, i.e. {@link #pointCount()}<minimalPointCount, then this method probably does not decompose this pattern and returns the 1-element list containing this instance as its element. But it is not guaranteed: if the method "knows" some decomposition, but estimation of the number of points can require a lot of resources, this method may ignore minimalPointCount argument.
However, there is a guarantee that if the number of points is 1 or 2, i.e. {@link #pointCount()}≤2, then this method always returns the 1-element list containing this instance as its element.
There is a guarantee that the elements of the resulting list cannot be further decomposed: this method, called for them with the same or larger minimalPointCount argument, always returns a list consisting of one element.
The number of space dimensions in all returned patterns ( {@link #dimCount()} is the same as in this one.
The result of this method is immutable (Collections.unmodifiableList). @param minimalPointCount this method usually does not decompose patterns that containless than minimalPointCount points. @return the decomposition of this pattern to Minkowski sum; always contains ≥1 elements. @throws IllegalArgumentException if the argument is negative.
| |
| |