001/*
002 * $Id: GroebnerBaseGGVSigSeqIter.java 5476 2016-03-25 17:57:05Z kredel $
003 */
004
005package edu.jas.gb;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import org.apache.log4j.Logger;
012
013import edu.jas.poly.ExpVector;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.structure.RingElem;
016
017
018/**
019 * Groebner Base GGV signature based sequential iterative algorithm. Implements
020 * Groebner bases.
021 * @param <C> coefficient type
022 * @author Heinz Kredel
023 * 
024 * @see edu.jas.application.GBAlgorithmBuilder
025 * @see edu.jas.gbufd.GBFactory
026 */
027
028public class GroebnerBaseGGVSigSeqIter<C extends RingElem<C>> extends GroebnerBaseSigSeqIter<C> {
029
030
031    private static final Logger logger = Logger.getLogger(GroebnerBaseGGVSigSeqIter.class);
032
033
034    //private static final boolean debug = logger.isDebugEnabled();
035
036
037    /**
038     * Constructor.
039     */
040    public GroebnerBaseGGVSigSeqIter() {
041        this(new SigReductionSeq<C>());
042    }
043
044
045    /**
046     * Constructor.
047     * @param red Reduction engine
048     */
049    public GroebnerBaseGGVSigSeqIter(SigReductionSeq<C> red) {
050        super(red);
051    }
052
053
054    /**
055     * S-Polynomial.
056     * @param A polynomial.
057     * @param B polynomial.
058     * @return spol(A,B) the S-polynomial of A and B.
059     */
060    @Override
061    GenPolynomial<C> SPolynomial(SigPoly<C> A, SigPoly<C> B) {
062        return sred.SPolynomialHalf(A, B);
063    }
064
065
066    /**
067     * Prune total pair list P.
068     * @param P pair list.
069     * @param syz list of exponent vectors representing syzygies.
070     * @return updated pair list.
071     */
072    @Override
073    List<SigPair<C>> pruneP(List<SigPair<C>> P, List<ExpVector> syz) {
074        List<SigPair<C>> res = new ArrayList<SigPair<C>>(P.size());
075        for (SigPair<C> p : P) {
076            ExpVector f = p.sigma.leadingExpVector();
077            if (f == null) {
078                continue;
079            }
080            boolean div = false;
081            for (ExpVector e : syz) {
082                if (f.multipleOf(e)) {
083                    div = true;
084                    break;
085                }
086            }
087            if (div) {
088                continue;
089            }
090            res.add(p);
091        }
092        return res;
093    }
094
095
096    /**
097     * Prune pair list of degree d.
098     * @param S pair list.
099     * @param syz list of exponent vectors representing syzygies.
100     * @param done list of treated polynomials.
101     * @param G polynomial with signature list.
102     * @return updated pair list.
103     */
104    @Override
105    List<SigPair<C>> pruneS(List<SigPair<C>> S, List<ExpVector> syz, List<SigPoly<C>> done, List<SigPoly<C>> G) {
106        List<SigPair<C>> res = new ArrayList<SigPair<C>>(S.size());
107        for (SigPair<C> p : S) {
108            ExpVector f = p.sigma.leadingExpVector();
109            if (f == null) {
110                continue;
111            }
112            boolean div = false;
113            for (ExpVector e : syz) {
114                if (f.multipleOf(e)) {
115                    div = true;
116                    break;
117                }
118            }
119            if (div) {
120                continue;
121            }
122            div = false;
123            for (SigPair<C> q : S) {
124                if (f.equals(q.sigma.leadingExpVector())) {
125                    if (p.pi.poly.compareTo(q.pi.poly) < 0) {
126                        div = true;
127                        break;
128                    }
129                }
130            }
131            if (div) {
132                continue;
133            }
134            div = false;
135            for (SigPair<C> q : res) {
136                if (f.equals(q.sigma.leadingExpVector())) {
137                    div = true;
138                    break;
139                }
140            }
141            if (div) {
142                continue;
143            }
144            res.add(p);
145            logger.debug("added p = " + p.sigma);
146        }
147        return res;
148    }
149
150
151    /**
152     * Initializes syzygy list.
153     * @param F polynomial list.
154     * @param G polynomial with signature list.
155     * @return list of exponent vectors representing syzygies.
156     */
157    @Override
158    List<ExpVector> initializeSyz(List<GenPolynomial<C>> F, List<SigPoly<C>> G) {
159        List<ExpVector> P = new ArrayList<ExpVector>();
160        for (GenPolynomial<C> p : F) {
161            if (p.isZERO()) {
162                continue;
163            }
164            P.add(p.leadingExpVector());
165        }
166        return P;
167    }
168
169
170    /**
171     * Update syzygy list.
172     * @param syz list of exponent vectors representing syzygies.
173     * @param r polynomial. <b>Note:</b> szy is modified to represent updated
174     *            list of exponent vectors.
175     */
176    @Override
177    void updateSyz(List<ExpVector> syz, SigPoly<C> r) {
178        if (r.poly.isZERO() && !r.sigma.isZERO()) {
179            syz.add(r.sigma.leadingExpVector());
180        }
181        return;
182    }
183
184}