Package cc.redberry.rings

Class FactorDecomposition<E>

java.lang.Object

cc.redberry.rings.FactorDecomposition<E>

All Implemented Interfaces:

Stringifiable<E>, Serializable, Iterable<E>

Direct Known Subclasses:

PolynomialFactorDecomposition

public class FactorDecomposition<E>
extends Object
implements Iterable<E>, Stringifiable<E>, Serializable

Factor decomposition of element. Unit coefficient of decomposition is stored in unit, factors returned by get(int) are non-units. This class is mutable.

Iterable specification provides iterator over non-unit factors only; to iterate over all factors including the constant factor use iterableWithUnit()

Since:

2.2

Author:

Stanislav Poslavsky

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field	Description
gnu.trove.list.array.TIntArrayList	exponents	exponents
List<E>	factors	factors
Ring<E>	ring	The ring
E	unit	unit coefficient

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	FactorDecomposition(Ring<E> ring, E unit, List<E> factors, gnu.trove.list.array.TIntArrayList exponents)

Method Summary

Modifier and Type	Method	Description
FactorDecomposition<E>	addAll(FactorDecomposition<E> other)	add all factors from other
FactorDecomposition<E>	addFactor(E factor, int exponent)	add another factor
FactorDecomposition<E>	addUnit(E unit)	add another unit factor
FactorDecomposition<E>	addUnit(E unit, int exponent)	add another unit factor
FactorDecomposition<E>	apply(Function<E,E> mapper)
FactorDecomposition<E>	applyConstantFactor()	Raise all factors to its corresponding exponents
FactorDecomposition<E>	applyExponents()	Raise all factors to its corresponding exponents
FactorDecomposition<E>	canonical()	Sort factors.
FactorDecomposition<E>	clone()
FactorDecomposition<E>	dropExponents()	Set all exponents to one
FactorDecomposition<E>	dropFactor(int i)	Remove specified factor
FactorDecomposition<E>	dropUnit()	Drops constant factor from this (new instance returned)
static <E> FactorDecomposition<E>	empty(Ring<E> ring)	Empty factorization
boolean	equals(Object o)
E	get(int i)	Returns i-th factor
int	getExponent(int i)	Exponent of i-th factor
int	hashCode()
boolean	isTrivial()	Whether this is a trivial factorization (contains only one factor)
boolean	isUnit(E element)
Iterable<E>	iterableWithUnit()	Iterator over all factors including a unit one
Iterator<E>	iterator()
<R> FactorDecomposition<R>	mapTo(Ring<R> othRing, Function<E,R> mapper)
E	multiply()	Multiply factors
E	multiplyIgnoreExponents()	Multiply with no account for exponents
static <E> FactorDecomposition<E>	of(Ring<E> ring, E... factors)	Factor decomposition with specified factors and exponents
static <E> FactorDecomposition<E>	of(Ring<E> ring, E unit, List<E> factors, gnu.trove.list.array.TIntArrayList exponents)	Factor decomposition with specified factors and exponents
static <E> FactorDecomposition<E>	of(Ring<E> ring, Collection<E> factors)	Factor decomposition with specified factors and exponents
void	raiseExponents(long val)	Multiply each exponent by a given factor
FactorDecomposition<E>	setUnit(E unit)	Sets the unit factor
int	size()	Number of non-constant factors
E	squareFreePart()	Square-free part
Stream<E>	stream()	Stream of all factors
Stream<E>	streamWithoutUnit()	Stream of all factors except unit
int	sumExponents()	Sum all exponents
E[]	toArrayWithoutUnit()	Array of factors without constant factor
E[]	toArrayWithUnit()	Array of factors without constant factor
String	toString()
String	toString(IStringifier<E> stringifier)	convert this to string with the use of stringifier
static <E> FactorDecomposition<E>	unit(Ring<E> ring, E unit)	Unit factorization

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Field Detail

ring

public final Ring<E> ring

The ring

unit

public E unit

unit coefficient

factors

public final List<E> factors

factors

exponents

public final gnu.trove.list.array.TIntArrayList exponents

exponents

Constructor Detail

FactorDecomposition

protected FactorDecomposition(Ring<E> ring,
                              E unit,
                              List<E> factors,
                              gnu.trove.list.array.TIntArrayList exponents)

Method Detail

iterator

public Iterator<E> iterator()

Specified by:

iterator in interface Iterable<E>

iterableWithUnit

public Iterable<E> iterableWithUnit()

Iterator over all factors including a unit one

Returns:

iterator over all factors including a unit one

isUnit

public boolean isUnit(E element)

get

public E get(int i)

Returns i-th factor

getExponent

public int getExponent(int i)

Exponent of i-th factor

size

public int size()

Number of non-constant factors

isTrivial

public boolean isTrivial()

Whether this is a trivial factorization (contains only one factor)

sumExponents

public int sumExponents()

Sum all exponents

raiseExponents

public void raiseExponents(long val)

Multiply each exponent by a given factor

setUnit

public FactorDecomposition<E> setUnit(E unit)

Sets the unit factor

addUnit

public FactorDecomposition<E> addUnit(E unit)

add another unit factor

addUnit

public FactorDecomposition<E> addUnit(E unit,
                                      int exponent)

add another unit factor

addFactor

public FactorDecomposition<E> addFactor(E factor,
                                        int exponent)

add another factor

addAll

public FactorDecomposition<E> addAll(FactorDecomposition<E> other)

add all factors from other

applyExponents

public FactorDecomposition<E> applyExponents()

Raise all factors to its corresponding exponents

applyConstantFactor

public FactorDecomposition<E> applyConstantFactor()

Raise all factors to its corresponding exponents

dropExponents

public FactorDecomposition<E> dropExponents()

Set all exponents to one

dropUnit

public FactorDecomposition<E> dropUnit()

Drops constant factor from this (new instance returned)

dropFactor

public FactorDecomposition<E> dropFactor(int i)

Remove specified factor

stream

public Stream<E> stream()

Stream of all factors

streamWithoutUnit

public Stream<E> streamWithoutUnit()

Stream of all factors except unit

toArrayWithoutUnit

public E[] toArrayWithoutUnit()

Array of factors without constant factor

toArrayWithUnit

public E[] toArrayWithUnit()

Array of factors without constant factor

multiply

public E multiply()

Multiply factors

multiplyIgnoreExponents

public E multiplyIgnoreExponents()

Multiply with no account for exponents

squareFreePart

public E squareFreePart()

Square-free part

canonical

public FactorDecomposition<E> canonical()

Sort factors.

mapTo

public <R> FactorDecomposition<R> mapTo(Ring<R> othRing,
                                        Function<E,R> mapper)

apply

public FactorDecomposition<E> apply(Function<E,E> mapper)

toString

public String toString(IStringifier<E> stringifier)

Description copied from interface: Stringifiable

convert this to string with the use of stringifier

Specified by:

toString in interface Stringifiable<E>

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

clone

public FactorDecomposition<E> clone()

Overrides:

clone in class Object

unit

public static <E> FactorDecomposition<E> unit(Ring<E> ring,
                                              E unit)

Unit factorization

empty

public static <E> FactorDecomposition<E> empty(Ring<E> ring)

Empty factorization

of

public static <E> FactorDecomposition<E> of(Ring<E> ring,
                                            E unit,
                                            List<E> factors,
                                            gnu.trove.list.array.TIntArrayList exponents)

Factor decomposition with specified factors and exponents

Parameters:

ring - the ring

unit - the unit coefficient

factors - the factors

exponents - the exponents

of

public static <E> FactorDecomposition<E> of(Ring<E> ring,
                                            E... factors)

Factor decomposition with specified factors and exponents

Parameters:

ring - the ring

factors - factors

of

public static <E> FactorDecomposition<E> of(Ring<E> ring,
                                            Collection<E> factors)

Factor decomposition with specified factors and exponents

Parameters:

ring - the ring

factors - factors