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}