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}