001/*
002 * $Id$
003 */
004
005package edu.jas.gbufd;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import org.apache.logging.log4j.Logger;
012import org.apache.logging.log4j.LogManager; 
013
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenPolynomialRing;
016import edu.jas.poly.PolyUtil;
017import edu.jas.structure.GcdRingElem;
018import edu.jas.ufd.FactorAbstract;
019import edu.jas.ufd.FactorFactory;
020
021
022/**
023 * Multiplicative set of irreducible polynomials. a, b in M implies a*b in M, 1
024 * in M.
025 * @param <C> coefficient type
026 * @author Heinz Kredel
027 */
028public class MultiplicativeSetFactors<C extends GcdRingElem<C>> extends MultiplicativeSet<C> {
029
030
031    private static final Logger logger = LogManager.getLogger(MultiplicativeSetFactors.class);
032
033
034    //private static final boolean debug = logger.isDebugEnabled();
035
036
037    /**
038     * Factors decomposition engine.
039     */
040    protected final FactorAbstract<C> engine;
041
042
043    /**
044     * MultiplicativeSet constructor. Constructs an empty multiplicative set.
045     * @param ring polynomial ring factory for coefficients.
046     */
047    public MultiplicativeSetFactors(GenPolynomialRing<C> ring) {
048        super(ring);
049        engine = FactorFactory.getImplementation(ring.coFac);
050    }
051
052
053    /**
054     * MultiplicativeSet constructor.
055     * @param ring polynomial ring factory for coefficients.
056     * @param ms a list of non-zero polynomials.
057     * @param eng factorization engine.
058     */
059    protected MultiplicativeSetFactors(GenPolynomialRing<C> ring, List<GenPolynomial<C>> ms,
060                    FactorAbstract<C> eng) {
061        super(ring, ms);
062        engine = eng;
063    }
064
065
066    /**
067     * toString.
068     * @see java.lang.Object#toString()
069     */
070    @Override
071    public String toString() {
072        return "MultiplicativeSetFactors" + mset;
073    }
074
075
076    /**
077     * Comparison with any other object.
078     * @see java.lang.Object#equals(java.lang.Object)
079     */
080    @Override
081    public boolean equals(Object B) {
082        if (!(B instanceof MultiplicativeSetFactors)) {
083            return false;
084        }
085        return super.equals(B);
086    }
087
088
089    /**
090     * Hash code for this multiplicative set.
091     * @see java.lang.Object#hashCode()
092     */
093    @Override
094    public int hashCode() {
095        return super.hashCode();
096    }
097
098
099    /**
100     * Add polynomial to mset.
101     * @param cc polynomial to be added to mset.
102     * @return new multiplicative set.
103     */
104    @Override
105    public MultiplicativeSetFactors<C> add(GenPolynomial<C> cc) {
106        if (cc == null || cc.isZERO() || cc.isConstant()) {
107            return this;
108        }
109        if (ring.coFac.isField()) {
110            cc = cc.monic();
111        }
112        GenPolynomial<C> c = removeFactors(cc);
113        if (c.isConstant()) {
114            logger.info("skipped unit or constant = {}", c);
115            return this;
116        }
117        List<GenPolynomial<C>> list = engine.factorsRadical(c);
118        logger.info("factorsRadical = {}", list);
119        if (ring.coFac.isField()) {
120            list = PolyUtil.<C> monic(list);
121        }
122        List<GenPolynomial<C>> ms = new ArrayList<GenPolynomial<C>>(mset);
123        for (GenPolynomial<C> p : list) {
124            if (!p.isConstant() && !p.isZERO()) {
125                if (!mset.contains(p)) {
126                    logger.info("added to irreducible mset = {}", p);
127                    ms.add(p);
128                }
129            }
130        }
131        return new MultiplicativeSetFactors<C>(ring, ms, engine);
132    }
133
134
135    /**
136     * Replace polynomial list of mset.
137     * @param L polynomial list to replace mset.
138     * @return new multiplicative set.
139     */
140    @Override
141    public MultiplicativeSetFactors<C> replace(List<GenPolynomial<C>> L) {
142        MultiplicativeSetFactors<C> ms = new MultiplicativeSetFactors<C>(ring);
143        if (L == null || L.size() == 0) {
144            return ms;
145        }
146        for (GenPolynomial<C> p : L) {
147            ms = ms.add(p);
148        }
149        return ms;
150    }
151
152}