Source code

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