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