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