Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.application;
006
007
008import java.io.FileNotFoundException;
009import java.io.FileReader;
010import java.io.StringReader;
011import java.io.IOException;
012import java.io.FileInputStream;
013import java.io.InputStreamReader;
014import java.io.Reader;
015import java.io.BufferedReader;
016import java.nio.charset.Charset;
017import java.util.List;
018import java.util.Arrays;
019
020import edu.jas.gb.SolvableGroebnerBase;
021import edu.jas.gb.SolvableGroebnerBaseAbstract;
022import edu.jas.gb.SolvableGroebnerBaseParallel;
023import edu.jas.gb.SolvableGroebnerBaseSeq;
024import edu.jas.gb.SolvableGroebnerBaseSeqPairParallel;
025import edu.jas.gb.SolvableReduction;
026import edu.jas.gb.SolvableReductionPar;
027import edu.jas.gb.SolvableReductionSeq;
028import edu.jas.kern.ComputerThreads;
029import edu.jas.poly.GenPolynomialTokenizer;
030import edu.jas.poly.GenSolvablePolynomial;
031import edu.jas.poly.GenSolvablePolynomialRing;
032import edu.jas.poly.PolynomialList;
033import edu.jas.util.CatReader;
034
035
036/**
037 * Simple setup to run a solvable GB example. <br> Usage: RunSGB
038 * [seq|par|par+] [irr|left|right|two] &lt;file&gt; #procs
039 * @author Heinz Kredel
040 */
041public class RunSGB {
042
043    /**
044     * Check result GB if it is a GB.
045     */
046    static boolean doCheck = false;
047
048
049    /**
050     * main method to be called from commandline <br> Usage: RunSGB
051     * [seq|seq+|par|par+] [irr|left|right|two] &lt;file&gt; #procs
052     */
053    @SuppressWarnings("unchecked")
054    public static void main(String[] args) {
055
056        String[] allkinds = new String[] { "seq", "seq+", 
057                                           "par", "par+", 
058                                           //"dist", "dist+", ,
059                                           //"disthyb", "disthyb+", 
060                                           //"cli" 
061                                         }; // must be last
062        String[] allmeth = new String[] { "irr", "left", "right", "two" };
063
064        String usage = "Usage: RunSGB [ "
065                        + join(allkinds, " | ") 
066                        //+ "[port] ] " 
067                        + " ] ["
068                        + join(allmeth, " | ") 
069                        + "] <file> " 
070                        + "#threads " 
071                        //+ "#procs/#threadsPerNode " 
072                        //+ "[machinefile] ";
073                        + "[check] ";
074
075        if (args.length < 3) {
076            System.out.println("args: " + Arrays.toString(args));
077            System.out.println(usage);
078            return;
079        }
080
081        boolean plusextra = false;
082        String kind = args[0];
083        boolean sup = false;
084        int k = -1;
085        for (int i = 0; i < args.length; i++) {
086            int j = indexOf(allkinds, args[i]);
087            if (j < 0) {
088                continue;
089            }
090            sup = true;
091            k = i;
092            kind = args[k];
093            break;
094        }
095        if (!sup) {
096            System.out.println("args(sup): " + Arrays.toString(args));
097            System.out.println(usage);
098            return;
099        }
100        if (kind.indexOf("+") >= 0) {
101            plusextra = true;
102        }
103        System.out.println("kind: " + kind + ", k = " + k);
104
105        String action = args[k + 1];
106        sup = false;
107        int j = indexOf(allmeth, action);
108        if (j < 0) {
109            System.out.println(usage);
110            return;
111        }
112
113        String filename = args[k + 2];
114
115        int threads = 0;
116        if (kind.startsWith("par")) {
117            if (args.length < 4) {
118                System.out.println("args(par): " + Arrays.toString(args));
119                System.out.println(usage);
120                return;
121            }
122            String tup = args[k + 3];
123            String t = tup;
124            try {
125                threads = Integer.parseInt(t);
126            } catch (NumberFormatException e) {
127                e.printStackTrace();
128                System.out.println("args(threads): " + Arrays.toString(args));
129                System.out.println(usage);
130                return;
131            }
132            if (threads < 1) {
133                threads = 1;
134            }
135        }
136        j = indexOf(args, "check");
137        if (j >= 0) {
138            doCheck = true;
139        }
140
141        Reader problem = RunGB.getReader(filename);
142        if (problem == null) {
143            System.out.println("args(file): " + filename);
144            System.out.println("args(file): examples.jar(" + filename + ")");
145            System.out.println("args(file): " + Arrays.toString(args));
146            System.out.println(usage);
147            return;
148        }
149        RingFactoryTokenizer rftok = new RingFactoryTokenizer(problem);
150        GenSolvablePolynomialRing spfac = null;
151        try {
152            spfac = rftok.nextSolvablePolynomialRing();
153            rftok = null;
154        } catch (IOException e) {
155            e.printStackTrace();
156            return;
157        }
158        Reader polyreader = new CatReader(new StringReader("("),problem); // ( has gone
159        //Reader polyreader = problem; 
160        GenPolynomialTokenizer tok = new GenPolynomialTokenizer(spfac,polyreader);
161        PolynomialList S = null;
162        try {
163            S = new PolynomialList(spfac,tok.nextSolvablePolynomialList());
164        } catch (IOException e) {
165            e.printStackTrace();
166            return;
167        }
168        System.out.println("S =\n" + S);
169
170        if (kind.startsWith("seq")) {
171            runSequential(S, action, plusextra);
172        } else if (kind.startsWith("par")) {
173            runParallel(S, threads, action, plusextra);
174        }
175        ComputerThreads.terminate();
176        try {
177            problem.close();
178        } catch (IOException ignored) {
179        }
180    }
181
182
183    /**
184     * run Sequential.
185     * @param S polynomial list.
186     * @param action what to to.
187     */
188    @SuppressWarnings("unchecked")
189    static void runSequential(PolynomialList S, String action, boolean plusextra) {
190        List<GenSolvablePolynomial> L = S.list;
191        List<GenSolvablePolynomial> G = null;
192        long t;
193        SolvableReduction sred = new SolvableReductionSeq();
194        SolvableGroebnerBase sbb = null;
195        if (plusextra) {
196            //sbb = new SolvableGroebnerBaseSeqPlusextra();
197            //System.out.println("SolvableGroebnerBaseSeqPlusextra not implemented using SolvableGroebnerBaseSeq");
198            sbb = new SolvableGroebnerBaseSeq(sred);
199        } else {
200            sbb = new SolvableGroebnerBaseSeq();
201        }
202        t = System.currentTimeMillis();
203        System.out.println("\nSolvable GB [" + action + "] sequential ...");
204        if (action.equals("irr")) {
205            G = sred.leftIrreducibleSet(L);
206        }
207        if (action.equals("left")) {
208            G = sbb.leftGB(L);
209        }
210        if (action.equals("right")) {
211            G = sbb.rightGB(L);
212        }
213        if (action.equals("two")) {
214            G = sbb.twosidedGB(L);
215        }
216        if (G == null) {
217            System.out.println("unknown action = " + action + "\n");
218            return;
219        }
220        S = new PolynomialList(S.ring, G);
221        System.out.println("G =\n" + S);
222        System.out.println("G.size() = " + G.size());
223        t = System.currentTimeMillis() - t;
224        if (plusextra) {
225            System.out.print("seq+, ");
226        } else {
227            System.out.print("seq, ");
228        }
229        System.out.println("time = " + t + " milliseconds");
230        checkGB(S);
231        System.out.println("");
232    }
233
234
235    /**
236     * run Parallel.
237     * @param S polynomial list.
238     * @param action what to to.
239     */
240    @SuppressWarnings("unchecked")
241    static void runParallel(PolynomialList S, int threads, String action, boolean plusextra) {
242        List<GenSolvablePolynomial> L = S.list;
243        List<GenSolvablePolynomial> G = null;
244        long t;
245        SolvableReduction sred = new SolvableReductionPar();
246        SolvableGroebnerBaseParallel sbb = null;
247        SolvableGroebnerBaseSeqPairParallel sbbs = null;
248        if (plusextra) {
249            sbbs = new SolvableGroebnerBaseSeqPairParallel(threads);
250        } else {
251            sbb = new SolvableGroebnerBaseParallel(threads);
252        }
253
254        t = System.currentTimeMillis();
255        System.out.println("\nSolvable GB [" + action + "] parallel " + threads + " threads ...");
256        if (action.equals("irr")) {
257            G = sred.leftIrreducibleSet(L);
258        }
259        if (action.equals("left")) {
260            if (plusextra) {
261                G = sbbs.leftGB(L);
262            } else {
263                G = sbb.leftGB(L);
264            }
265        }
266        if (action.equals("right")) {
267            if (plusextra) {
268                G = sbbs.rightGB(L);
269            } else {
270                G = sbb.rightGB(L);
271            }
272        }
273        if (action.equals("two")) {
274            if (plusextra) {
275                G = sbbs.twosidedGB(L);
276            } else {
277                G = sbb.twosidedGB(L);
278            }
279        }
280        if (G == null) {
281            System.out.println("unknown action = " + action + "\n");
282            return;
283        }
284        if (G.size() > 0) {
285            S = new PolynomialList(G.get(0).ring, G);
286        } else {
287            S = new PolynomialList(S.ring, G);
288        }
289        System.out.println("G =\n" + S);
290        System.out.println("G.size() = " + G.size());
291        t = System.currentTimeMillis() - t;
292        if (plusextra) {
293            System.out.print("p+ ");
294        } else {
295            System.out.print("p ");
296        }
297        System.out.println("= " + threads + ", time = " + t + " milliseconds");
298        checkGB(S);
299        System.out.println("");
300        if (plusextra) {
301            sbbs.terminate();
302        } else {
303            sbb.terminate();
304        }
305    }
306
307
308    @SuppressWarnings("unchecked")
309    static void checkGB(PolynomialList S) {
310        if (!doCheck) {
311            return;
312        }
313        SolvableGroebnerBaseAbstract sbb = new SolvableGroebnerBaseSeq();
314        long t = System.currentTimeMillis();
315        boolean chk = sbb.isLeftGB(S.list,false);
316        t = System.currentTimeMillis() - t;
317        System.out.println("check isGB = " + chk + " in " + t + " milliseconds");
318    }
319
320
321    static int indexOf(String[] args, String s) {
322        for (int i = 0; i < args.length; i++) {
323            if (s.equals(args[i])) {
324                return i;
325            }
326        }
327        return -1;
328    }
329
330
331    static String join(String[] args, String d) {
332        StringBuffer sb = new StringBuffer();
333        for (int i = 0; i < args.length; i++) {
334            if (i > 0) {
335                sb.append(d);
336            }
337            sb.append(args[i]);
338        }
339        return sb.toString();
340    }
341
342}