public abstract class AbstractWeightedPattern extends java.lang.Object implements WeightedPattern
A skeletal implementation of the WeightedPattern
interface to minimize
the effort required to implement this interface.
This implementation is based on using some "parent" pattern, implementing Pattern
interface
and passed to the constructor.
All methods of this class, excepting declared in the WeightedPattern
interface,
just call the same methods of the parent pattern.
To complete implementation, you just need to implement several methods from
the WeightedPattern
interface.
AlgART Laboratory 2007–2014
Modifier and Type  Field and Description 

protected Pattern 
parent
The parent pattern.

MAX_COORDINATE
Modifier  Constructor and Description 

protected 
AbstractWeightedPattern(Pattern parent)
Creates a new weighted pattern on the base of the given parent one.

Modifier and Type  Method and Description 

java.util.List<java.util.List<Pattern>> 
allUnionDecompositions(int minimalPointCount)
Returns a nonempty list of all best or almost best
union decompositions
with equal or similar "quality",
i.e. with the same or almost same summary number of points in all Minkowski decompositions
of all returned patterns. 
Pattern 
carcass()
Returns the carcass of this pattern.

RectangularArea 
coordArea()
Returns the minimal and maximal coordinates
among all points of this pattern for all dimensions.

Point 
coordMax()
Returns the point, each coordinate of which
is equal to the maximal corresponding coordinate
among all points of this pattern.

Point 
coordMin()
Returns the point, each coordinate of which
is equal to the minimal corresponding coordinate
among all points of this pattern.

Range 
coordRange(int coordIndex)
Returns the minimal and maximal coordinate with the given index
(
Point.coord(coordIndex) )
among all points of this pattern. 
int 
dimCount()
Returns the number of space dimensions of this pattern.

boolean 
hasMinkowskiDecomposition()
Returns true if and only if the Minkowski decomposition,
returned by
minkowskiDecomposition(0) call,
consists of 2 or more patterns:
minkowskiDecomposition(0) .size()>1. 
boolean 
isConstant()
This implementation returns
weightRange() .size() ==0.0. 
boolean 
isSurelyInteger()
Returns true if this pattern is integer:
all coordinates of all points of this pattern are integer numbers.

boolean 
isSurelyOriginPoint()
Returns true if this pattern consists of the single point and
this point is the origin of coordinates.

boolean 
isSurelySinglePoint()
Returns true if this pattern consists of the single point, i.e.
if
pointCount() ==1. 
double 
largePointCount()
Returns the number of points in this pattern as double value.

Pattern 
maxBound(int coordIndex)
Returns the maximal boundary of this pattern along the given axis:
a pattern consisting of all points of this pattern, for which there are
no other points with greater coordinate #coordIndex
and same other coordinates.

int 
maxCarcassMultiplier()
Returns the maximal multiplier k, for which the calculation of
the Minkowski multiple k⊗P can be optimized by using the carcass of this pattern P.

Pattern 
minBound(int coordIndex)
Returns the minimal boundary of this pattern along the given axis:
a pattern consisting of all points of this pattern, for which there are
no other points with less coordinate #coordIndex
and same other coordinates.

Pattern 
minkowskiAdd(Pattern added)
Calculates and returns the Minkowski sum of this and specified patterns.

java.util.List<Pattern> 
minkowskiDecomposition(int minimalPointCount)
Returns the Minkowski decomposition:
a nonempty list of patterns P_{0}, P_{1}, ..., P_{n−1},
such that this pattern P (the point set represented by it)
is a Minkowski sum of them (of the point sets represented by them):

Pattern 
minkowskiSubtract(Pattern subtracted)
Calculates and returns the erosion of this pattern by specified pattern
or null if this erosion is the empty set.

WeightedPattern 
multiply(double multiplier)
Returns the pattern consisting of points, generated from points of this instance
by multiplying on the mult argument via
IPoint.multiply(double) method. 
long 
pointCount()
Returns the number of points in this pattern.

java.util.Set<Point> 
points()
Returns a set of all points of this pattern.

java.util.List<WeightedPattern> 
productDecomposition(int minimalPointCount)
This implementation returns Collections.singletonList(this).

Pattern 
projectionAlongAxis(int coordIndex)
Returns the projection of this pattern along the given axis.

UniformGridPattern 
round()
Returns this pattern, every point of which is rounded to the nearest integer point.

IRectangularArea 
roundedCoordArea()
Returns the same result as
Pattern.coordArea() method,
but all minimal and maximal coordinates are rounded to integer values
by StrictMath.round operation. 
IRange 
roundedCoordRange(int coordIndex)
Returns the same result as
Pattern.coordRange(int coordIndex) method,
but both minimal and maximal coordinates are rounded to integer values
by StrictMath.round operation. 
java.util.Set<IPoint> 
roundedPoints()
Returns the set of all
integer points , obtained from the points of this pattern
(results of points() method by rounding with help of
Point.toRoundedPoint() method. 
abstract WeightedPattern 
scale(double... multipliers)
Returns this pattern, scaled by the specified multipliers along all coordinates.

abstract WeightedPattern 
shift(IPoint shift)
Returns the pattern shifted by the argument, that is consisting of points
with the same
weights ,
generated from points of this instance by adding the argument via IPoint.add(IPoint) method. 
WeightedPattern 
shift(Point shift)
Returns this pattern, shifted by the argument.

WeightedPattern 
symmetric()
This implementation calls
multiply(1.0) . 
java.util.List<Pattern> 
unionDecomposition(int minimalPointCount)
Returns a union decomposition:
a nonempty list of patterns P_{0}, P_{1}, ..., P_{n−1},
such that this pattern P (the point set represented by it)
is the settheoretical union of them (of the point sets represented by them):

abstract double 
weight(IPoint point)
Returns the weight of the given point of the pattern.

abstract Range 
weightRange()
Returns the minimal and maximal weights of all points of this pattern.

protected final Pattern parent
protected AbstractWeightedPattern(Pattern parent)
parent
 the parent pattern, serving most of all methods of this instance.java.lang.NullPointerException
 if the argument is null.public int dimCount()
Pattern
There is a guarantee, that this method always works very quickly (O(1) operations) and without exceptions.
public long pointCount()
Pattern
Warning! This method can work slowly for some forms of large patterns:
the required time can be O(N), where N is the number of points (result of this method).
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError.
There is a guarantee, that if this object implements QuickPointCountPattern
interface,
then this method works very quickly (O(1) operations) and without exceptions.
There is a guarantee, that if this object implements DirectPointSetPattern
interface,
then the result of this method is not greater than Integer.MAX_VALUE.
Note: if this method returns some value greater than Integer.MAX_VALUE,
it means that you cannot use Pattern.points()
and Pattern.roundedPoints()
methods,
because Java Set object cannot contain more than Integer.MAX_VALUE elements.
pointCount
in interface Pattern
points
in this pattern.Pattern.largePointCount()
,
Pattern.isSurelySinglePoint()
,
QuickPointCountPattern.isPointCountVeryLarge()
public double largePointCount()
Pattern
Pattern.pointCount()
method is not greater than Long.MAX_VALUE,
there is a guarantee that this method returns the same result, cast to double type.
Warning! This method can work slowly for some forms of large patterns:
the required time can be O(N), where N is the number of points (result of this method).
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError.
There is a guarantee, that if this object implements QuickPointCountPattern
interface,
then this method works very quickly (O(1) operations) and without exceptions.
largePointCount
in interface Pattern
points
in this pattern as double value.QuickPointCountPattern.isPointCountVeryLarge()
public java.util.Set<Point> points()
Pattern
The result of this method is immutable (Collections.unmodifiableSet). Moreover, the result is always the same for different calls of this method for the same instance — there are no ways to change it, in particular, via any custom methods of the implementation class (it is a conclusion from the common requirement, that all implementations of this interface must be immutable).
The returned set is always nonempty,
and the number of its elements is always equal to Pattern.pointCount()
.
Warning! This method can work slowly for some forms of large patterns.
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError.
This method surely fails (throws one of these exception), if the total number of points
Pattern.pointCount()
>Integer.MAX_VALUE, because Java Set object
cannot contain more than Integer.MAX_VALUE elements.
For example, implementations of the rectangular patterns
allow to successfully define a very large 3D parallelepiped
TooManyPointsInPatternError
)
for n=2000 (2000^{3}>Integer.MAX_VALUE).
There is a guarantee, that if this object implements DirectPointSetPattern
interface,
then this method requires not greater than O(N) operations and memory
(N=pointCount()
)
and never throws TooManyPointsInPatternError
.
Note: this method works very quickly (O(1) operations) in SimplePattern
class.
public java.util.Set<IPoint> roundedPoints()
Pattern
Returns the set of all integer points
, obtained from the points of this pattern
(results of points()
method by rounding with help of
Point.toRoundedPoint()
method.
In other words, the results of this method is the same as the result of the following code:
Set<IPoint> result = new HashSet<IPoint>(); // or another Set implementation for (Point p :points()
) { result.add(p.toRoundedPoint()
); } result = Collections.unmodifiableSet(result);
The result of this method is immutable (Collections.unmodifiableSet). Moreover, the result is always the same for different calls of this method for the same instance — there are no ways to change it, in particular, via any custom methods of the implementation class (it is a conclusion from the common requirement, that all implementations of this interface must be immutable).
The returned set is always nonempty.
Note: the number of resulting points can be less than Pattern.pointCount()
, because some
real points can be rounded to the same integer points.
According the basic restriction to pattern coordinates (see
the comments to this interface
, section "Coordinate restrictions"),
you may be sure that you will able
to create an integer uniformgrid
pattern by passing the result of this method
to Patterns.newIntegerPattern(java.util.Collection)
.
Warning! This method can work slowly or throw TooManyPointsInPatternError
/ OutOfMemoryError in the same situations as Pattern.points()
method.
There is a guarantee, that if this object implements DirectPointSetPattern
interface,
then this method requires not greater than O(N) operations and memory
(N=pointCount()
)
and never throws TooManyPointsInPatternError
.
Please compare with Pattern.round()
method, which always works quickly and without exceptions also
for the case of RectangularPattern
.
roundedPoints
in interface Pattern
public Range coordRange(int coordIndex)
Pattern
Point.coord(coordIndex)
)
among all points of this pattern.
The minimal coordinate will be r.min()
,
the maximal coordinate will be r.max()
,
where r is the result of this method.
There is a guarantee, that if this object implements RectangularPattern
interface,
then this method works very quickly (O(1) operations) and without exceptions.
Moreover, all patterns, implemented in this package, have very quick implementations of this method (O(1) operations). Also, the implementations of this method in this package never throw exceptions.
It is theoretically possible, that in custom implementations of this interface
(outside this package) this method will work slowly, up to O(N) operations,
N is the number of points in this pattern.
However, even in such implementations this method must not lead to
TooManyPointsInPatternError
/ OutOfMemoryError, like Pattern.points()
method.
coordRange
in interface Pattern
coordIndex
 the index of the coordinate (0 for x, 1 for y, 2 for z, etc.).Pattern.roundedCoordRange(int)
,
Pattern.coordMin()
,
Pattern.coordMax()
,
Pattern.coordArea()
public RectangularArea coordArea()
Pattern
coordCount()
==dimCount()
and a.range
(k)
is equal to coordRange
(k) for all k.
For example, in 2dimensional case the result is the circumscribed rectangle (with sides, parallel to the axes).
All, said in the comments to Pattern.coordRange(int)
method
about the speed and impossibility of TooManyPointsInPatternError
/ OutOfMemoryError,
is also true for this method.
coordArea
in interface Pattern
Pattern.roundedCoordArea()
public Point coordMin()
Pattern
Pattern.coordArea()
.min()
.
All, said in the comments to Pattern.coordRange(int)
method
about the speed and impossibility of TooManyPointsInPatternError
/ OutOfMemoryError,
is also true for this method.
public Point coordMax()
Pattern
Pattern.coordArea()
.max()
.
All, said in the comments to Pattern.coordRange(int)
method
about the speed and impossibility of TooManyPointsInPatternError
/ OutOfMemoryError,
is also true for this method.
public IRange roundedCoordRange(int coordIndex)
Pattern
Pattern.coordRange(int coordIndex)
method,
but both minimal and maximal coordinates are rounded to integer values
by StrictMath.round operation.
Equivalent to coordRange
(coordIndex).toRoundedRange()
.
According the basic restriction to pattern coordinates (see
the comments to this interface
, section "Coordinate restrictions"),
you may be sure that you will be able
to create an integer rectangular pattern
by passing the ranges, got by this method,
to Patterns.newRectangularIntegerPattern(IRange...)
.
All, said in the comments to Pattern.coordRange(int)
method
about the speed and impossibility of TooManyPointsInPatternError
/ OutOfMemoryError,
is also true for this method.
roundedCoordRange
in interface Pattern
coordIndex
 the index of the coordinate (0 for x, 1 for y, 2 for z, etc.).Pattern.roundedCoordArea()
public IRectangularArea roundedCoordArea()
Pattern
Pattern.coordArea()
method,
but all minimal and maximal coordinates are rounded to integer values
by StrictMath.round operation.
The method IRectangularArea.range(int coordIndex)
in the returned area
returns the same result as Pattern.roundedCoordRange(int coordIndex)
method in this object.
All, said in the comments to Pattern.coordRange(int)
method
about the speed and impossibility of TooManyPointsInPatternError
/ OutOfMemoryError,
is also true for this method.
roundedCoordArea
in interface Pattern
public boolean isSurelySinglePoint()
Pattern
pointCount()
==1.
There are no strict guarantees that this method always returns true if the pattern
consist of the single point. (In some complex situations, such analysis can
be too difficult. In particular, if the pattern is a Minkowski sum
, then limited floatingpoint precision can lead to equality of all points of the result.
Simple example: a Minkowski sum of twopoint onedimensional pattern, consisting of points
0.0 and 0.000001, and onepoint 2^{51}=2251799813685248.0, contains only 1 point 2^{51},
because the computer cannot represent precise value 2251799813685248.000001 in double type
and rounds it to 2251799813685248.0.
In such situations, this method sometimes may incorrectly return false.)
But there is the reverse guarantee: if this method returns true, the number of points in this pattern is always 1.
Unlike Pattern.pointCount()
method, there is a guarantee that this method
never works very slowly and cannot lead to TooManyPointsInPatternError
/ OutOfMemoryError.
In situations, when the number of points is very large
(and, so, Pattern.pointCount()
method is not safe in use),
this method must detect this fact in reasonable time and return false.
There is a guarantee, that if this object implements QuickPointCountPattern
interface,
then this method works very quickly (O(1) operations) and absolutely correctly
(always returns true if and only if pointCount()
==1).
isSurelySinglePoint
in interface Pattern
Pattern.isSurelyOriginPoint()
public boolean isSurelyOriginPoint()
Pattern
There are no strict guarantees that this method always returns true if the pattern
consist of the single point, equal to the origin of coordinates. (In some complex situations, such analysis can
be too difficult. In such situations, this method may incorrectly return false.)
But there is the reverse guarantee: if this method returns true,
the number of points in this pattern is always 1 and its only point is the origin of coordinates,
in terms of Point.isOrigin()
method.
Unlike Pattern.pointCount()
method, there is a guarantee that this method
never works very slowly and cannot lead to TooManyPointsInPatternError
/ OutOfMemoryError.
In situations, when the number of points is very large
(and, so, Pattern.pointCount()
method is not safe in use),
this method must detect this fact in reasonable time and return false.
There is a guarantee, that if this object implements QuickPointCountPattern
interface,
then this method works very quickly (O(1) operations) and absolutely correctly.
isSurelyOriginPoint
in interface Pattern
Pattern.isSurelySinglePoint()
public Pattern projectionAlongAxis(int coordIndex)
Pattern
Pattern.dimCount()
) is less by 1, than in this one.
More precisely, the resulting pattern consists of the points,
obtained from all points of this pattern by the call
point.projectionAlongAxis
(coordIndex).
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
The returned pattern always implements RectangularPattern
if this pattern implements RectangularPattern
.
The returned pattern always implements UniformGridPattern
if this pattern implements UniformGridPattern
.
There is a guarantee, that this method does not try to allocate much more memory,
that it is required for storing this pattern itself, and that it
never throws TooManyPointsInPatternError
.
For comparison, an attempt to do the same operation via getting all points (Pattern.points()
method),
correcting them and forming a new pattern via Patterns.newPattern(java.util.Collection)
will lead to TooManyPointsInPatternError
/ OutOfMemoryError for some forms of large patterns.
projectionAlongAxis
in interface Pattern
coordIndex
 the index of the coordinate (0 for xaxis , 1 for yaxis,
2 for zaxis, etc.).Pattern.dimCount()
is equal to
thisInstance.Pattern.dimCount()
1).public boolean isSurelyInteger()
Pattern
More precisely, if this method returns true, then there are the following guarantees:
Pattern.points()
method, as well as by
Pattern.coordMin()
/Pattern.coordMax()
, Point.isInteger()
method returns true;Pattern.minkowskiDecomposition(int)
,
Pattern.unionDecomposition(int)
and Pattern.allUnionDecompositions(int)
methods, is also surely integer,
i.e. this method also returns true for it.However, there are no strict guarantees that this method always returns true if the pattern is really integer. In other words, if this method returns false, there is no guarantee, that this pattern really contains some noninteger points — but it is probable.
Unlike Pattern.points()
method, there is a guarantee that this method
never works very slowly and cannot lead to TooManyPointsInPatternError
/ OutOfMemoryError.
In situations, when the number of points is very large
and there is a risk to fail with TooManyPointsInPatternError
/ OutOfMemoryError,
this method must detect this fact in reasonable time and return false.
See the comments to this interface
, section "Integer patterns", for more details.
isSurelyInteger
in interface Pattern
Minkowski
or union
)
assuredly contain only integer
points.public UniformGridPattern round()
Pattern
comments to this interface
, section "Uniformgrid patterns").
More precisely, the resulting pattern:
toRoundedPoint()
.toPoint()
;UniformGridPattern.originOfGrid()
=(0,0,...,0)
and unit steps UniformGridPattern.stepsOfGrid()
={1,1,..,1}.Note: the number of points in the result can be less than Pattern.pointCount()
, because some
real points can be rounded to the same integer points.
Warning! If this object is not DirectPointSetPattern
and is not RectangularPattern
, this method can work slowly for some large patterns:
the required time can be O(N), where N is the number of points.
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError. The situation is like in Pattern.points()
and Pattern.roundedPoints()
method.
There is a guarantee, that if this object implements DirectPointSetPattern
interface,
then this method requires not greater than O(N) operations and memory
(N=pointCount()
)
and never throws TooManyPointsInPatternError
.
There is a guarantee, that if this object implements RectangularPattern
interface,
then this method works quickly (O(1) operations) and without exceptions.
It is an important difference from Pattern.points()
and Pattern.roundedPoints()
method.
The theorem I, described in the comments to this interface
,
section "Coordinate restrictions", provides a guarantee that this method never throws
TooLargePatternCoordinatesException
.
public Pattern minBound(int coordIndex)
Pattern
Pattern.dimCount()
) is the same as in this one.
In other words, this method removes some points from this pattern according the following rule:
if this pattern contains several points p_{0}, p_{1}, ...,
p_{m−1} with identical projection to the given axis
(p_{i}.projectionAlongAxis
(coordIndex).equals(p_{j}.projectionAlongAxis
(coordIndex)) for all i, j),
then the resulting pattern contains only one from these points, for which
the given coordinate coord
(coordIndex) has the minimal value.
This method is especially useful for uniformgrid
patterns.
For example, in rectangular patterns
this method returns
one of the facets of the hyperparallelepiped.
In most cases (including all rectangular patterns
)
this method returns the same result as UniformGridPattern.lowerSurface(int)
;
but if the figure, described by this pattern, contains some "holes", the result of this method
contains fewer points than UniformGridPattern.lowerSurface(int)
.
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
The returned pattern always implements RectangularPattern
if this pattern implements RectangularPattern
.
The returned pattern always implements UniformGridPattern
if this pattern implements UniformGridPattern
.
Warning! If this object is not DirectPointSetPattern
and is not RectangularPattern
, this method can work slowly for some large patterns:
the required time can be O(N), where N is the number of points.
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError. The situation is like in Pattern.points()
and Pattern.roundedPoints()
method.
There is a guarantee, that if this object implements DirectPointSetPattern
interface,
then this method requires not greater than O(N) memory
(N=pointCount()
)
and never throws TooManyPointsInPatternError
.
There is a guarantee, that if this object implements RectangularPattern
interface,
then this method works quickly (O(1) operations) and without exceptions.
minBound
in interface Pattern
coordIndex
 the index of the coordinate (0 for xaxis , 1 for yaxis,
2 for zaxis, etc.).Pattern.maxBound(int)
public Pattern maxBound(int coordIndex)
Pattern
Pattern.dimCount()
) is the same as in this one.
In other words, this method removes some points from this pattern according the following rule:
if this pattern contains several points p_{0}, p_{1}, ...,
p_{m−1} with identical projection to the given axis
(p_{i}.projectionAlongAxis
(coordIndex).equals(p_{j}.projectionAlongAxis
(coordIndex)) for all i, j),
then the resulting pattern contains only one from these points, for which
the given coordinate coord
(coordIndex) has the maximal value.
This method is especially useful for uniformgrid
patterns.
For example, in rectangular patterns
this method returns
one of the facets of the hyperparallelepiped.
In most cases (including all rectangular patterns
)
this method returns the same result as UniformGridPattern.upperSurface(int)
;
but if the figure, described by this pattern, contains some "holes", the result of this method
contains fewer points than UniformGridPattern.upperSurface(int)
.
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
The returned pattern always implements RectangularPattern
if this pattern implements RectangularPattern
.
The returned pattern always implements UniformGridPattern
if this pattern implements UniformGridPattern
.
Warning! If this object is not DirectPointSetPattern
and is not RectangularPattern
, this method can work slowly for some large patterns:
the required time can be O(N), where N is the number of points.
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError. The situation is like in Pattern.points()
and Pattern.roundedPoints()
method.
There is a guarantee, that if this object implements DirectPointSetPattern
interface,
then this method requires not greater than O(N) memory
(N=pointCount()
)
and never throws TooManyPointsInPatternError
.
There is a guarantee, that if this object implements RectangularPattern
interface,
then this method works quickly (O(1) operations) and without exceptions.
maxBound
in interface Pattern
coordIndex
 the index of the coordinate (0 for xaxis , 1 for yaxis,
2 for zaxis, etc.).Pattern.minBound(int)
public Pattern carcass()
Pattern
Here A⊕B means the Minkowski sum
of patterns A and B,
k⊗P means P⊕P⊕...⊕P (k summands),
and kP means the pointwise geometrical multiplication of the pattern P by the multiplier k,
i.e. P.multiply
(k).
This method tries to find the minimal carcass, consisting of as little as possible number of points,
and the maximal value n, for which the formulas above are correct for the found carcass.
(The value 2^{n} is called the maximal carcass multiplier
and is returned by Pattern.maxCarcassMultiplier()
method.)
For example, for rectangular patterns
this method returns
the set of vertices of the hyperparallelepiped (in onedimensional case, the pair of segment ends),
and the corresponding n=+∞.
But this method does not guarantee that the returned result is always the minimal possible carcass
and that the found n is really maximal for this carcass.
This method allows to optimize calculation of the point set of a Minkowski multiple k⊗P.
It is really used in the pattern implementations, returned
by Patterns.newMinkowskiMultiplePattern(Pattern, int)
method:
the result of that method is not always an actual Minkowski sum of N equal patterns,
but can be (in the best case) an equal Minkowski sum of ~log_{2}N patterns
In the worst case (no optimization is possible), this method just returns this object (C=P),
and Pattern.maxCarcassMultiplier()
returns 2 (i.e. n=1).
The returned pattern has the same number of dimensions (Pattern.dimCount()
) as this one.
The returned pattern always implements UniformGridPattern
if this pattern implements UniformGridPattern
.
This method can require some time and memory for execution,
but never throws TooManyPointsInPatternError
.
public int maxCarcassMultiplier()
Pattern
Pattern.carcass()
method for more information.
Note: the returned value is always ≥2. If the correct value is greater than Integer.MAX_VALUE
(for example, for rectangular patterns
),
this method returns Integer.MAX_VALUE; in all other cases the returning value is a power of two.
This method can require some time and memory for execution,
but never throws TooManyPointsInPatternError
.
Usually an implementation caches the results of Pattern.carcass()
and this methods,
so this method works very quickly after the first call of Pattern.carcass()
.
maxCarcassMultiplier
in interface Pattern
carcass
.public Pattern minkowskiAdd(Pattern added)
Pattern
add
(b)" call).
Please see details in
Warning! This method can work slowly for some forms of large patterns.
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError.
Warning: this method can fail with TooLargePatternCoordinatesException
, if some of new points
violate restrictions, described in the comments to this interface
,
section "Coordinate restrictions".
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
.
The returned pattern always implements RectangularPattern
if this pattern and subtracted argument implement RectangularPattern
and both patterns have identical steps
(i.e. thisPattern.stepsOfGridEqual
(subtracted) returns true).
In this case, this method works very quickly and without
TooManyPointsInPatternError
/ OutOfMemoryError exceptions.
Please draw attention: there is another way to build a Minkowski sum,
namely the method Patterns.newMinkowskiSum(java.util.Collection)
.
That method does not perform actual calculations and returns a special implementation
of this interface (see comments to this interface
, section "Complex patterns").
Unlike that method, this one tries to actually calculate the Minkowski sum, saving (when possible)
the type of the original pattern: see above two guarantees about DirectPointSetPattern
and RectangularPattern
types. If it is impossible to represent the Minkowski sum
by Java class of this pattern, it is probable that the result will be constructed
as DirectPointSetUniformGridPattern
or as SimplePattern
.
minkowskiAdd
in interface Pattern
added
 another pattern.Patterns.newMinkowskiSum(java.util.Collection)
,
Pattern.minkowskiSubtract(Pattern)
public Pattern minkowskiSubtract(Pattern subtracted)
Pattern
add
(b)" call)
belongs to this pattern.
Please see more details in
Warning! This method can work slowly for some forms of large patterns.
In these cases, this method can also throw TooManyPointsInPatternError
or OutOfMemoryError.
Warning: this method can fail with TooLargePatternCoordinatesException
, if some of new points
violate restrictions, described in the comments to this interface
,
section "Coordinate restrictions". But it is obvious, that this exception
is impossible if the passed pattern "subtracted" contains the origin of coordinates
(in this case, the result is a subset of this pattern).
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
.
The returned pattern always implements RectangularPattern
if this pattern and subtracted argument implement RectangularPattern
and both patterns have identical steps
(i.e. thisPattern.stepsOfGridEqual
(subtracted) returns true).
In this case, this method works very quickly and without
TooManyPointsInPatternError
/ OutOfMemoryError exceptions.
minkowskiSubtract
in interface Pattern
subtracted
 another pattern.Pattern.minkowskiAdd(Pattern)
public java.util.List<Pattern> minkowskiDecomposition(int minimalPointCount)
Pattern
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(log_{2}N) points (sum of Pattern.pointCount()
values for all returned patterns),
where N is the number of points (Pattern.pointCount()
) in this pattern.
For example, a linear onedimensional segment {x: 0<=x<2^{m}}
is a Minkowski sum of m point pairs {0, 2^{i}}, i=0,1,...,m1.
There is no guarantee that this method returns a good decomposition. If this method cannot find required decomposition, it returns the 1element list containing this instance as the only element.
If the number of points in this pattern is less than the argument, i.e.
Pattern.pointCount()
<minimalPointCount, then this method probably does not
decompose this pattern and returns the 1element 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. Pattern.pointCount()
≤2, then this method always returns
the 1element 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 (Pattern.dimCount()
is the same as in this one.
The result of this method is immutable (Collections.unmodifiableList).
minkowskiDecomposition
in interface Pattern
minimalPointCount
 this method usually does not decompose patterns that contain
less than minimalPointCount points.public boolean hasMinkowskiDecomposition()
Pattern
minkowskiDecomposition(0)
call,
consists of 2 or more patterns:
minkowskiDecomposition(0)
.size()>1.
In some situations this method works essentially faster then the actual
minkowskiDecomposition(0)
call.
Note that if this method returns true, then Pattern.pointCount()
and
Pattern.largePointCount()
methods can work very slowly and even may fail with
OutOfMemoryError or TooManyPointsInPatternError
.
hasMinkowskiDecomposition
in interface Pattern
public java.util.List<Pattern> unionDecomposition(int minimalPointCount)
Pattern
This method tries to find such decomposition, that all patterns P_{i} have good
Minkowski decompositions
and the summary number of points in all Minkowski decompositions
minkowskiDecomposition(minimalPointCount)
If the number of points in this pattern is less than the argument, i.e.
Pattern.pointCount()
<minimalPointCount, then this method probably does not
decompose this pattern and returns the 1element list containing this instance as its element.
Moreover, this method tries to build such decomposition, that every element P_{i}
in the resulting list contains ≥minimalPointCount elements.
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 (Pattern.dimCount()
is the same as in this one.
The result of this method is immutable (Collections.unmodifiableList).
unionDecomposition
in interface Pattern
minimalPointCount
 this method usually does not decompose patterns that contain
less than minimalPointCount points.public java.util.List<java.util.List<Pattern>> allUnionDecompositions(int minimalPointCount)
Pattern
union decompositions
with equal or similar "quality",
i.e. with the same or almost same summary number of points in all Minkowski decompositions
of all returned patterns.
This method is a useful addition to Pattern.unionDecomposition(int)
method for a case,
when there are several union decompositions with similar "quality".
In this case an algorithm, using union decompositions, is able to choose
the best from several variants according additional algorithmspecific criteria.
The number of space dimensions in all returned patterns (Pattern.dimCount()
is the same as in this one.
The result of this method and the elements of the result are immutable (Collections.unmodifiableList).
allUnionDecompositions
in interface Pattern
minimalPointCount
 this method usually does not decompose patterns that contain
less than minimalPointCount points.public WeightedPattern shift(Point shift)
Pattern
More precisely, the resulting pattern consists of the points,
obtained from all points of this pattern by the call point.add
(shift).
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
The returned pattern always implements RectangularPattern
if this pattern implements RectangularPattern
.
The returned pattern always implements UniformGridPattern
if this pattern implements UniformGridPattern
.
There is a guarantee, that this method does not try to allocate much more memory,
that it is required for storing this pattern itself, and that it
never throws TooManyPointsInPatternError
.
For comparison, an attempt to do the same operation via getting all points (Pattern.points()
method),
correcting them and forming a new pattern via Patterns.newPattern(java.util.Collection)
will lead to TooManyPointsInPatternError
/ OutOfMemoryError for some forms of large patterns.
Warning: this method can fail with TooLargePatternCoordinatesException
, if some of new points
violate restrictions, described in the comments to this interface
,
section "Coordinate restrictions" (for example, due to very large shift).
However, TooLargePatternCoordinatesException
is impossible in many important cases, when
this pattern is an integer pattern and each coordinate
coord
(j)TooLargePatternCoordinatesException
in the following situations:
coordMin()
.symmetric()
,coordMax()
.symmetric()
,symmetric()
, where p is
some of the points
if this integer pattern.See more details in the comments to this interface
,
section "Coordinate restrictions", the theorem II.
public abstract WeightedPattern shift(IPoint shift)
WeightedPattern
weights
,
generated from points of this instance by adding the argument via IPoint.add(IPoint)
method.shift
in interface WeightedPattern
shift
 the shift.public WeightedPattern multiply(double multiplier)
WeightedPattern
IPoint.multiply(double)
method.
If mult is not an integer, the generated real coordinates are rounded to integer values.
If several source points are rounded to the same integer point, the weights
of the resulting points may differ from the weights of the source ones,
but the sum of all weights will be approximately same.
If the all source points are transformed to different points,
their weights are preserved.
Please note: if mult is not an integer, the algorithm of rounding is not strictly specified! However, you can be sure that the new pattern will be near from the precise result.
multiply
in interface Pattern
multiply
in interface WeightedPattern
multiplier
 the multiplier.Pattern.scale(double...)
public abstract WeightedPattern scale(double... multipliers)
Pattern
More precisely, the resulting pattern consists of the points,
obtained from all points of this pattern by the call
point.scale
(multipliers).
The returned pattern always implements DirectPointSetPattern
if this pattern implements DirectPointSetPattern
The returned pattern always implements RectangularPattern
if this pattern implements RectangularPattern
.
The returned pattern always implements UniformGridPattern
if this pattern implements UniformGridPattern
.
There is a guarantee, that this method does not try to allocate much more memory,
that it is required for storing this pattern itself, and that it
never throws TooManyPointsInPatternError
.
For comparison, an attempt to do the same operation via getting all points (Pattern.points()
method),
correcting them and forming a new pattern via Patterns.newPattern(java.util.Collection)
will lead to TooManyPointsInPatternError
/ OutOfMemoryError for some forms of large patterns.
Warning: this method can fail with TooLargePatternCoordinatesException
, if some of new points
violate restrictions, described in the comments to this interface
,
section "Coordinate restrictions" (for example, due to very large multipliers).
However, such failure is obviously impossible, if all multipliers are
in range 1.0<=multipliers[k]<=1.0.
scale
in interface Pattern
scale
in interface WeightedPattern
multipliers
 the scales along coordinates.Pattern.multiply(double)
public WeightedPattern symmetric()
multiply(1.0)
.
There are no reasons to override this method usually.symmetric
in interface Pattern
symmetric
in interface WeightedPattern
public abstract double weight(IPoint point)
WeightedPattern
weight
in interface WeightedPattern
point
 some integer point
.public abstract Range weightRange()
WeightedPattern
weightRange
in interface WeightedPattern
public boolean isConstant()
weightRange()
.size()
==0.0.
There are no reasons to override this method usually.isConstant
in interface WeightedPattern
public java.util.List<WeightedPattern> productDecomposition(int minimalPointCount)
productDecomposition
in interface WeightedPattern
minimalPointCount
 this method does not try to decompose patterns that contain
less than minimalPointCount points.java.lang.IllegalArgumentException
 if the argument is negative.