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