Source code

001/*
002 * $Id: ModSolvableGroebnerBaseAbstract.java 5872 2018-07-20 16:01:46Z kredel $
003 */
004
005package edu.jas.gbmod;
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.GenSolvablePolynomial;
015import edu.jas.poly.GenSolvablePolynomialRing;
016import edu.jas.poly.ModuleList;
017import edu.jas.poly.PolynomialList;
018import edu.jas.poly.TermOrder;
019import edu.jas.structure.RingElem;
020
021
022/**
023 * Module solvable Groebner Bases abstract class. Implements module solvable
024 * Groebner bases and GB test.
025 * @param <C> coefficient type
026 * @author Heinz Kredel
027 * @deprecated use respective methods from SolvableGroebnerBaseAbstract
028 */
029@Deprecated
030public abstract class ModSolvableGroebnerBaseAbstract<C extends RingElem<C>> implements
031                ModSolvableGroebnerBase<C> {
032
033
034    private static final Logger logger = LogManager.getLogger(ModSolvableGroebnerBaseAbstract.class);
035
036
037    private static final boolean debug = logger.isDebugEnabled();
038
039
040    /**
041     * Module left Groebner base test.
042     * @param M a module basis.
043     * @return true, if M is a left Groebner base, else false.
044     */
045    public boolean isLeftGB(ModuleList<C> M) {
046        if (M == null || M.list == null) {
047            return true;
048        }
049        if (M.rows == 0 || M.cols == 0) {
050            return true;
051        }
052        int modv = M.cols; // > 0  
053        PolynomialList<C> F = M.getPolynomialList();
054        return isLeftGB(modv, F.castToSolvableList());
055    }
056
057
058    /**
059     * Left Groebner base using pairlist class.
060     * @param M a module basis.
061     * @return leftGB(M) a left Groebner base for M.
062     */
063    @SuppressWarnings("unchecked")
064    public ModuleList<C> leftGB(ModuleList<C> M) {
065        ModuleList<C> N = M;
066        if (M == null || M.list == null) {
067            return N;
068        }
069        if (M.rows == 0 || M.cols == 0) {
070            return N;
071        }
072        PolynomialList<C> F = M.getPolynomialList();
073        if (debug) {
074            logger.info("F left +++++++++++++++++++ \n" + F);
075        }
076        GenSolvablePolynomialRing<C> sring = (GenSolvablePolynomialRing<C>) F.ring;
077        int modv = M.cols;
078        List<GenSolvablePolynomial<C>> G = leftGB(modv, F.castToSolvableList());
079        F = new PolynomialList<C>(sring, G);
080        if (debug) {
081            logger.info("G left +++++++++++++++++++ \n" + F);
082        }
083        N = F.getModuleList(modv);
084        return N;
085    }
086
087
088    /**
089     * Module twosided Groebner base test.
090     * @param M a module basis.
091     * @return true, if M is a twosided Groebner base, else false.
092     */
093    public boolean isTwosidedGB(ModuleList<C> M) {
094        if (M == null || M.list == null) {
095            return true;
096        }
097        if (M.rows == 0 || M.cols == 0) {
098            return true;
099        }
100        PolynomialList<C> F = M.getPolynomialList();
101        int modv = M.cols; // > 0  
102        return isTwosidedGB(modv, F.castToSolvableList());
103    }
104
105
106    /**
107     * Twosided Groebner base using pairlist class.
108     * @param M a module basis.
109     * @return tsGB(M) a twosided Groebner base for M.
110     */
111    @SuppressWarnings("unchecked")
112    public ModuleList<C> twosidedGB(ModuleList<C> M) {
113        ModuleList<C> N = M;
114        if (M == null || M.list == null) {
115            return N;
116        }
117        if (M.rows == 0 || M.cols == 0) {
118            return N;
119        }
120        PolynomialList<C> F = M.getPolynomialList();
121        GenSolvablePolynomialRing<C> sring = (GenSolvablePolynomialRing<C>) F.ring;
122        int modv = M.cols;
123        List<GenSolvablePolynomial<C>> G = twosidedGB(modv, F.castToSolvableList());
124        F = new PolynomialList<C>(sring, G);
125        N = F.getModuleList(modv);
126        return N;
127    }
128
129
130    /**
131     * Module right Groebner base test.
132     * @param M a module basis.
133     * @return true, if M is a right Groebner base, else false.
134     */
135    public boolean isRightGB(ModuleList<C> M) {
136        if (M == null || M.list == null) {
137            return true;
138        }
139        if (M.rows == 0 || M.cols == 0) {
140            return true;
141        }
142        int modv = M.cols; // > 0  
143        PolynomialList<C> F = M.getPolynomialList();
144        //System.out.println("F test = " + F);
145        return isRightGB(modv, F.castToSolvableList());
146    }
147
148
149    /**
150     * Right Groebner base using pairlist class.
151     * @param M a module basis.
152     * @return rightGB(M) a right Groebner base for M.
153     */
154    @SuppressWarnings("unchecked")
155    public ModuleList<C> rightGB(ModuleList<C> M) {
156        ModuleList<C> N = M;
157        if (M == null || M.list == null) {
158            return N;
159        }
160        if (M.rows == 0 || M.cols == 0) {
161            return N;
162        }
163        if (debug) {
164            logger.info("M ====================== \n" + M);
165        }
166        TermOrder to = M.ring.tord;
167        if (to.getSplit() <= M.ring.nvar) {
168            throw new IllegalArgumentException("extended TermOrders not supported for rightGBs: " + to);
169        }
170        List<List<GenSolvablePolynomial<C>>> mlist = M.castToSolvableList();
171        GenSolvablePolynomialRing<C> sring = (GenSolvablePolynomialRing<C>) M.ring;
172        GenSolvablePolynomialRing<C> rring = sring.reverse(true); //true
173        sring = rring.reverse(true); // true
174
175        List<List<GenSolvablePolynomial<C>>> nlist = new ArrayList<List<GenSolvablePolynomial<C>>>(M.rows);
176        for (List<GenSolvablePolynomial<C>> row : mlist) {
177            List<GenSolvablePolynomial<C>> nrow = new ArrayList<GenSolvablePolynomial<C>>(row.size());
178            for (GenSolvablePolynomial<C> elem : row) {
179                GenSolvablePolynomial<C> nelem = (GenSolvablePolynomial<C>) elem.reverse(rring);
180                nrow.add(nelem);
181            }
182            nlist.add(nrow);
183        }
184        ModuleList<C> rM = new ModuleList<C>(rring, nlist);
185        if (debug) {
186            logger.info("rM -------------------- \n" + rM);
187        }
188        ModuleList<C> rMg = leftGB(rM);
189        if (debug) {
190            logger.info("rMg -------------------- \n" + rMg);
191            logger.info("isLeftGB(rMg) ---------- " + isLeftGB(rMg));
192        }
193        mlist = rMg.castToSolvableList();
194        nlist = new ArrayList<List<GenSolvablePolynomial<C>>>(rMg.rows);
195        for (List<GenSolvablePolynomial<C>> row : mlist) {
196            List<GenSolvablePolynomial<C>> nrow = new ArrayList<GenSolvablePolynomial<C>>(row.size());
197            for (GenSolvablePolynomial<C> elem : row) {
198                GenSolvablePolynomial<C> nelem = (GenSolvablePolynomial<C>) elem.reverse(sring);
199                nrow.add(nelem);
200            }
201            nlist.add(nrow);
202        }
203        ModuleList<C> Mg = new ModuleList<C>(sring, nlist);
204        if (debug) {
205            logger.info("Mg -------------------- \n" + Mg);
206            logger.info("isRightGB(Mg) --------- " + isRightGB(Mg));
207        }
208        return Mg;
209    }
210
211
212    /**
213     * Cleanup and terminate ThreadPool.
214     */
215    public void terminate() {
216        logger.info("terminate not implemented");
217    }
218
219
220    /**
221     * Cancel ThreadPool.
222     */
223    public int cancel() {
224        logger.info("cancel not implemented");
225        return 0;
226    }
227
228}