001    /*
002     * Copyright (C) 2008-2010 by Holger Arndt
003     * 
004     * This file is part of the Universal Java Matrix Package (UJMP).
005     * See the NOTICE file distributed with this work for additional
006     * information regarding copyright ownership and licensing.
007     *
008     * UJMP is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU Lesser General Public License as
010     * published by the Free Software Foundation; either version 2
011     * of the License, or (at your option) any later version.
012     *
013     * UJMP is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016     * GNU Lesser General Public License for more details.
017     *
018     * You should have received a copy of the GNU Lesser General Public
019     * License along with UJMP; if not, write to the
020     * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
021     * Boston, MA  02110-1301  USA
022     */
023    
024    package org.ujmp.core.benchmark;
025    
026    import java.util.LinkedList;
027    import java.util.List;
028    
029    import org.ujmp.core.mapmatrix.DefaultMapMatrix;
030    import org.ujmp.core.util.MathUtil;
031    import org.ujmp.core.util.StringUtil;
032    import org.ujmp.core.util.UJMPSettings;
033    
034    public class BenchmarkConfig extends DefaultMapMatrix<String, Object> {
035            private static final long serialVersionUID = 2267893158983793396L;
036    
037            public static final double NOTAVAILABLE = 0;
038    
039            public static final double ERROR = Double.NaN;
040    
041            public BenchmarkConfig() {
042                    put("name", null);
043    
044                    put("numberOfThreads", UJMPSettings.getNumberOfThreads());
045                    put("reverse", false);
046                    put("shuffle", false);
047                    put("gcMemory", true);
048                    put("purgeMemory", true);
049    
050                    put("burnInRuns", 3);
051                    put("runs", 25);
052                    put("minTrialCount", 1);
053                    put("maxTrialCount", 5);
054                    put("maxTime", 10000); // maximal time for one operation
055                    put("maxStd", 10); // maximal standard deviation results may vary
056                    put("maxSize", 10000); // maximal size of a matrix
057    
058                    put("runTimesScalar", true);
059                    put("runPlusMatrix", true);
060                    put("runTranspose", true);
061                    put("runMtimes", true);
062                    put("runInv", true);
063                    put("runInvSPD", true);
064                    put("runSolveSquare", true);
065                    put("runSolveTall", true);
066                    put("runSVD", true);
067                    put("runEig", true);
068                    put("runChol", false);
069                    put("runLU", false);
070                    put("runQR", false);
071    
072                    put("runDefaultDenseDoubleMatrix2D", true);
073                    put("runArrayDenseDoubleMatrix2D", true);
074                    put("runBlockDenseDoubleMatrix2D", true);
075                    put("runJBlasDenseDoubleMatrix2D", true);
076                    put("runMTJDenseDoubleMatrix2D", true);
077                    put("runOjalgoDenseDoubleMatrix2D", true);
078                    put("runOrbitalDenseDoubleMatrix2D", false);
079                    put("runOwlpackDenseDoubleMatrix2D", false);
080                    put("runJScienceDenseDoubleMatrix2D", false);
081                    put("runJSciDenseDoubleMatrix2D", false);
082                    put("runJMathArrayDenseDoubleMatrix2D", false);
083                    put("runJLinAlgDenseDoubleMatrix2D", false);
084                    put("runParallelColtDenseDoubleMatrix2D", true);
085                    put("runColtDenseDoubleMatrix2D", true);
086                    put("runSSTDenseDoubleMatrix2D", false);
087                    put("runCommonsMathArrayDenseDoubleMatrix2D", true);
088                    put("runCommonsMathBlockDenseDoubleMatrix2D", true);
089                    put("runEJMLDenseDoubleMatrix2D", true);
090                    put("runJamaDenseDoubleMatrix2D", true);
091                    put("runJampackDenseDoubleMatrix2D", false);
092                    put("runJMatricesDenseDoubleMatrix2D", false);
093                    put("runMantissaDenseDoubleMatrix2D", false);
094                    put("runVecMathDenseDoubleMatrix2D", false);
095    
096                    put("useJBlas", true);
097                    put("useBlockMatrixMultiply", true);
098                    put("useOjalgo", true);
099                    put("useEJML", true);
100                    put("useMTJ", true);
101                    put("useParallelColt", true);
102                    put("useCommonsMath", true);
103    
104                    put("defaultBlockSize", 100);
105            }
106    
107            public List<long[]> getSVDSizes() {
108                    return getSquareSizes();
109            }
110    
111            public boolean isRunTimesScalar() {
112                    return MathUtil.getBoolean(get("runTimesScalar"));
113            }
114    
115            public void setRunTimesScalar(boolean runTimesScalar) {
116                    put("runTimesScalar", runTimesScalar);
117            }
118    
119            public boolean isRunPlusMatrix() {
120                    return MathUtil.getBoolean(get("runPlusMatrix"));
121            }
122    
123            public void setRunPlusMatrix(boolean runPlusMatrix) {
124                    put("runPlusMatrix", runPlusMatrix);
125            }
126    
127            public boolean isRunTranspose() {
128                    return MathUtil.getBoolean(get("runTranspose"));
129            }
130    
131            public void setRunTranspose(boolean runTranspose) {
132                    put("runTranspose", runTranspose);
133            }
134    
135            public boolean isRunMtimes() {
136                    return MathUtil.getBoolean(get("runMtimes"));
137            }
138    
139            public void setRunMtimes(boolean runMtimes) {
140                    put("runMtimes", runMtimes);
141            }
142    
143            public boolean isRunInv() {
144                    return MathUtil.getBoolean(get("runInv"));
145            }
146    
147            public boolean isRunInvSPD() {
148                    return MathUtil.getBoolean(get("runInvSPD"));
149            }
150    
151            public void setRunInv(boolean runInv) {
152                    put("runInv", runInv);
153            }
154    
155            public void setRunInvSPD(boolean runInv) {
156                    put("runInvSPD", runInv);
157            }
158    
159            public boolean isRunSolveSquare() {
160                    return MathUtil.getBoolean(get("runSolveSquare"));
161            }
162    
163            public void setRunSolveSquare(boolean runSolveSquare) {
164                    put("runSolveSquare", runSolveSquare);
165            }
166    
167            public boolean isRunSolveTall() {
168                    return MathUtil.getBoolean(get("runSolveTall"));
169            }
170    
171            public void setRunSolveTall(boolean runSolveTall) {
172                    put("runSolveTall", runSolveTall);
173            }
174    
175            public boolean isRunSVD() {
176                    return MathUtil.getBoolean(get("runSVD"));
177            }
178    
179            public void setRunSVD(boolean runSVD) {
180                    put("runSVD", runSVD);
181            }
182    
183            public int getNumberOfThreads() {
184                    return MathUtil.getInt(get("numberOfThreads"));
185            }
186    
187            public void setNumberOfThreads(int numberOfThreads) {
188                    put("numberOfThreads", numberOfThreads);
189            }
190    
191            public boolean isRunEig() {
192                    return MathUtil.getBoolean(get("runEig"));
193            }
194    
195            public void setRunEig(boolean runEig) {
196                    put("runEig", runEig);
197            }
198    
199            public boolean isRunChol() {
200                    return MathUtil.getBoolean(get("runChol"));
201            }
202    
203            public void setRunChol(boolean runChol) {
204                    put("runChol", runChol);
205            }
206    
207            public boolean isRunLU() {
208                    return MathUtil.getBoolean(get("runLU"));
209            }
210    
211            public void setRunLU(boolean runLU) {
212                    put("runLU", runLU);
213            }
214    
215            public boolean isRunQR() {
216                    return MathUtil.getBoolean(get("runQR"));
217            }
218    
219            public void setRunQR(boolean runQR) {
220                    put("runQR", runQR);
221            }
222    
223            public int getBurnInRuns() {
224                    return MathUtil.getInt(get("burnInRuns"));
225            }
226    
227            public int getMinTrialCount() {
228                    return MathUtil.getInt(get("minTrialCount"));
229            }
230    
231            public void setMinTrialCount(int minTrialCount) {
232                    put("minTrialCount", minTrialCount);
233            }
234    
235            public int getMaxTrialCount() {
236                    return MathUtil.getInt(get("maxTrialCount"));
237            }
238    
239            public void setMaxTrialCount(int maxTrialCount) {
240                    put("maxTrialCount", maxTrialCount);
241            }
242    
243            public void setBurnInRuns(int burnInRuns) {
244                    put("burnInRuns", burnInRuns);
245            }
246    
247            public int getRuns() {
248                    return MathUtil.getInt(get("runs"));
249            }
250    
251            public void setRuns(int runs) {
252                    put("runs", runs);
253            }
254    
255            public List<long[]> getSquareSizes() {
256                    List<long[]> sizes = new LinkedList<long[]>();
257                    int maxSize = getMaxSize();
258                    sizes.add(new long[] { 2, 2 });
259                    if (maxSize >= 3) {
260                            sizes.add(new long[] { 3, 3 });
261                    }
262                    if (maxSize >= 4) {
263                            sizes.add(new long[] { 4, 4 });
264                    }
265                    if (maxSize >= 5) {
266                            sizes.add(new long[] { 5, 5 });
267                    }
268                    if (maxSize >= 10) {
269                            sizes.add(new long[] { 10, 10 });
270                    }
271                    if (maxSize >= 20) {
272                            sizes.add(new long[] { 20, 20 });
273                    }
274                    if (maxSize >= 50) {
275                            sizes.add(new long[] { 50, 50 });
276                    }
277                    if (maxSize >= 100) {
278                            sizes.add(new long[] { 100, 100 });
279                    }
280                    if (maxSize >= 200) {
281                            sizes.add(new long[] { 200, 200 });
282                    }
283                    if (maxSize >= 500) {
284                            sizes.add(new long[] { 500, 500 });
285                    }
286                    if (maxSize >= 1000) {
287                            sizes.add(new long[] { 1000, 1000 });
288                    }
289                    if (maxSize >= 2000) {
290                            sizes.add(new long[] { 2000, 2000 });
291                    }
292                    if (maxSize >= 5000) {
293                            sizes.add(new long[] { 5000, 5000 });
294                    }
295                    if (maxSize >= 10000) {
296                            sizes.add(new long[] { 10000, 10000 });
297                    }
298                    return sizes;
299            }
300    
301            public List<long[]> getTallSizes() {
302                    List<long[]> sizes = new LinkedList<long[]>();
303                    for (long[] s : getSquareSizes()) {
304                            s = s.clone();
305                            s[0] *= 2;
306                            sizes.add(s);
307                    }
308                    return sizes;
309            }
310    
311            public List<long[]> getTransposeSizes() {
312                    return getSquareSizes();
313            }
314    
315            public List<long[]> getTimesSizes() {
316                    return getSquareSizes();
317            }
318    
319            public List<long[]> getPlusSizes() {
320                    return getSquareSizes();
321            }
322    
323            public List<long[]> getMtimesSizes() {
324                    return getSquareSizes();
325            }
326    
327            public List<long[]> getInvSizes() {
328                    return getSquareSizes();
329            }
330    
331            public List<long[]> getSolveSquareSizes() {
332                    return getSquareSizes();
333            }
334    
335            public List<long[]> getSolveTallSizes() {
336                    return getTallSizes();
337            }
338    
339            public List<long[]> getEigSizes() {
340                    return getSquareSizes();
341            }
342    
343            public List<long[]> getQRSizes() {
344                    return getSquareSizes();
345            }
346    
347            public List<long[]> getLUSizes() {
348                    return getSquareSizes();
349            }
350    
351            public List<long[]> getCholSizes() {
352                    return getSquareSizes();
353            }
354    
355            public boolean isRunDefaultDenseDoubleMatrix2D() {
356                    return MathUtil.getBoolean(get("runDefaultDenseDoubleMatrix2D"));
357            }
358    
359            public void setRunDefaultDenseDoubleMatrix2D(boolean runDefaultDenseDoubleMatrix2D) {
360                    put("runDefaultDenseDoubleMatrix2D", runDefaultDenseDoubleMatrix2D);
361            }
362    
363            public boolean isRunArrayDenseDoubleMatrix2D() {
364                    return MathUtil.getBoolean(get("runArrayDenseDoubleMatrix2D"));
365            }
366    
367            public boolean isRunBlockDenseDoubleMatrix2D() {
368                    return MathUtil.getBoolean(get("runBlockDenseDoubleMatrix2D"));
369            }
370    
371            public void setRunArrayDenseDoubleMatrix2D(boolean runArrayDenseDoubleMatrix2D) {
372                    put("runArrayDenseDoubleMatrix2D", runArrayDenseDoubleMatrix2D);
373            }
374    
375            public void setRunBlockDenseDoubleMatrix2D(boolean runBlockDenseDoubleMatrix2D) {
376                    put("runBlockDenseDoubleMatrix2D", runBlockDenseDoubleMatrix2D);
377            }
378    
379            public boolean isRunMTJDenseDoubleMatrix2D() {
380                    return MathUtil.getBoolean(get("runMTJDenseDoubleMatrix2D"));
381            }
382    
383            public void setRunMTJDenseDoubleMatrix2D(boolean runMTJDenseDoubleMatrix2D) {
384                    put("runMTJDenseDoubleMatrix2D", runMTJDenseDoubleMatrix2D);
385            }
386    
387            public boolean isRunOjalgoDenseDoubleMatrix2D() {
388                    return MathUtil.getBoolean(get("runOjalgoDenseDoubleMatrix2D"));
389            }
390    
391            public void setRunOjalgoDenseDoubleMatrix2D(boolean runOjalgoDenseDoubleMatrix2D) {
392                    put("runOjalgoDenseDoubleMatrix2D", runOjalgoDenseDoubleMatrix2D);
393            }
394    
395            public boolean isRunOrbitalDenseDoubleMatrix2D() {
396                    return MathUtil.getBoolean(get("runOrbitalDenseDoubleMatrix2D"));
397            }
398    
399            public void setRunOrbitalDenseDoubleMatrix2D(boolean runOrbitalDenseDoubleMatrix2D) {
400                    put("runOrbitalDenseDoubleMatrix2D", runOrbitalDenseDoubleMatrix2D);
401            }
402    
403            public boolean isRunOwlpackDenseDoubleMatrix2D() {
404                    return MathUtil.getBoolean(get("runOwlpackDenseDoubleMatrix2D"));
405            }
406    
407            public void setRunOwlpackDenseDoubleMatrix2D(boolean runOwlpackDenseDoubleMatrix2D) {
408                    put("runOwlpackDenseDoubleMatrix2D", runOwlpackDenseDoubleMatrix2D);
409            }
410    
411            public boolean isRunJScienceDenseDoubleMatrix2D() {
412                    return MathUtil.getBoolean(get("runJScienceDenseDoubleMatrix2D"));
413            }
414    
415            public void setRunJScienceDenseDoubleMatrix2D(boolean runJScienceDenseDoubleMatrix2D) {
416                    put("runJScienceDenseDoubleMatrix2D", runJScienceDenseDoubleMatrix2D);
417            }
418    
419            public boolean isRunJSciDenseDoubleMatrix2D() {
420                    return MathUtil.getBoolean(get("runJSciDenseDoubleMatrix2D"));
421            }
422    
423            public void setRunJSciDenseDoubleMatrix2D(boolean runJSciDenseDoubleMatrix2D) {
424                    put("runJSciDenseDoubleMatrix2D", runJSciDenseDoubleMatrix2D);
425            }
426    
427            public boolean isRunJMathArrayDenseDoubleMatrix2D() {
428                    return MathUtil.getBoolean(get("runJMathArrayDenseDoubleMatrix2D"));
429            }
430    
431            public void setRunJMathArrayDenseDoubleMatrix2D(boolean runJMathArrayDenseDoubleMatrix2D) {
432                    put("runJMathArrayDenseDoubleMatrix2D", runJMathArrayDenseDoubleMatrix2D);
433            }
434    
435            public boolean isRunJLinAlgDenseDoubleMatrix2D() {
436                    return MathUtil.getBoolean(get("runJLinAlgDenseDoubleMatrix2D"));
437            }
438    
439            public void setRunJLinAlgDenseDoubleMatrix2D(boolean runJLinAlgDenseDoubleMatrix2D) {
440                    put("runJLinAlgDenseDoubleMatrix2D", runJLinAlgDenseDoubleMatrix2D);
441            }
442    
443            public boolean isRunParallelColtDenseDoubleMatrix2D() {
444                    return MathUtil.getBoolean(get("runParallelColtDenseDoubleMatrix2D"));
445            }
446    
447            public void setRunParallelColtDenseDoubleMatrix2D(boolean runParallelColtDenseDoubleMatrix2D) {
448                    put("runParallelColtDenseDoubleMatrix2D", runParallelColtDenseDoubleMatrix2D);
449            }
450    
451            public boolean isRunColtDenseDoubleMatrix2D() {
452                    return MathUtil.getBoolean(get("runColtDenseDoubleMatrix2D"));
453            }
454    
455            public void setRunColtDenseDoubleMatrix2D(boolean runColtDenseDoubleMatrix2D) {
456                    put("runColtDenseDoubleMatrix2D", runColtDenseDoubleMatrix2D);
457            }
458    
459            public boolean isRunSSTDenseDoubleMatrix2D() {
460                    return MathUtil.getBoolean(get("runSSTDenseDoubleMatrix2D"));
461            }
462    
463            public void setRunSSTDenseDoubleMatrix2D(boolean runSSTDenseDoubleMatrix2D) {
464                    put("runSSTDenseDoubleMatrix2D", runSSTDenseDoubleMatrix2D);
465            }
466    
467            public boolean isRunCommonsMathArrayDenseDoubleMatrix2D() {
468                    return MathUtil.getBoolean(get("runCommonsMathArrayDenseDoubleMatrix2D"));
469            }
470    
471            public void setRunCommonsMathArrayDenseDoubleMatrix2D(
472                            boolean runCommonsMathArrayDenseDoubleMatrix2D) {
473                    put("runCommonsMathArrayDenseDoubleMatrix2D", runCommonsMathArrayDenseDoubleMatrix2D);
474            }
475    
476            public boolean isRunCommonsMathBlockDenseDoubleMatrix2D() {
477                    return MathUtil.getBoolean(get("runCommonsMathBlockDenseDoubleMatrix2D"));
478            }
479    
480            public void setRunCommonsMathBlockDenseDoubleMatrix2D(
481                            boolean runCommonsMathBlockDenseDoubleMatrix2D) {
482                    put("runCommonsMathBlockDenseDoubleMatrix2D", runCommonsMathBlockDenseDoubleMatrix2D);
483            }
484    
485            public boolean isRunEJMLDenseDoubleMatrix2D() {
486                    return MathUtil.getBoolean(get("runEJMLDenseDoubleMatrix2D"));
487            }
488    
489            public void setRunEJMLDenseDoubleMatrix2D(boolean runEJMLDenseDoubleMatrix2D) {
490                    put("runEJMLDenseDoubleMatrix2D", runEJMLDenseDoubleMatrix2D);
491            }
492    
493            public boolean isRunJamaDenseDoubleMatrix2D() {
494                    return MathUtil.getBoolean(get("runJamaDenseDoubleMatrix2D"));
495            }
496    
497            public void setRunJamaDenseDoubleMatrix2D(boolean runJamaDenseDoubleMatrix2D) {
498                    put("runJamaDenseDoubleMatrix2D", runJamaDenseDoubleMatrix2D);
499            }
500    
501            public boolean isRunJampackDenseDoubleMatrix2D() {
502                    return MathUtil.getBoolean(get("runJampackDenseDoubleMatrix2D"));
503            }
504    
505            public void setRunJampackDenseDoubleMatrix2D(boolean runJampackDenseDoubleMatrix2D) {
506                    put("runJampackDenseDoubleMatrix2D", runJampackDenseDoubleMatrix2D);
507            }
508    
509            public boolean isRunJMatricesDenseDoubleMatrix2D() {
510                    return MathUtil.getBoolean(get("runJMatricesDenseDoubleMatrix2D"));
511            }
512    
513            public void setRunJMatricesDenseDoubleMatrix2D(boolean runJMatricesDenseDoubleMatrix2D) {
514                    put("runJMatricesDenseDoubleMatrix2D", runJMatricesDenseDoubleMatrix2D);
515            }
516    
517            public boolean isRunMantissaDenseDoubleMatrix2D() {
518                    return MathUtil.getBoolean(get("runMantissaDenseDoubleMatrix2D"));
519            }
520    
521            public void setRunMantissaDenseDoubleMatrix2D(boolean runMantissaDenseDoubleMatrix2D) {
522                    put("runMantissaDenseDoubleMatrix2D", runMantissaDenseDoubleMatrix2D);
523            }
524    
525            public boolean isRunVecMathDenseDoubleMatrix2D() {
526                    return MathUtil.getBoolean(get("runVecMathDenseDoubleMatrix2D"));
527            }
528    
529            public void setRunVecMathDenseDoubleMatrix2D(boolean runVecMathDenseDoubleMatrix2D) {
530                    put("runVecMathDenseDoubleMatrix2D", runVecMathDenseDoubleMatrix2D);
531            }
532    
533            public int getMaxTime() {
534                    return MathUtil.getInt(get("maxTime"));
535            }
536    
537            public int getMaxSize() {
538                    return MathUtil.getInt(get("maxSize"));
539            }
540    
541            public void setMaxTime(int maxTime) {
542                    put("maxTime", maxTime);
543            }
544    
545            public void setMaxSize(int maxSize) {
546                    put("maxSize", maxSize);
547            }
548    
549            public double getMaxStd() {
550                    return MathUtil.getDouble(get("maxStd"));
551            }
552    
553            public void setMaxStd(double maxStd) {
554                    put("maxStd", maxStd);
555            }
556    
557            public boolean isGCMemory() {
558                    return MathUtil.getBoolean(get("gcMemory"));
559            }
560    
561            public void setGCMemory(boolean gcMemory) {
562                    put("gcMemory", gcMemory);
563            }
564    
565            public boolean isPurgeMemory() {
566                    return MathUtil.getBoolean(get("purgeMemory"));
567            }
568    
569            public void setPurgeMemory(boolean purgeMemory) {
570                    put("purgeMemory", purgeMemory);
571            }
572    
573            public boolean isShuffle() {
574                    return MathUtil.getBoolean(get("shuffle"));
575            }
576    
577            public void setShuffle(boolean shuffle) {
578                    put("shuffle", shuffle);
579            }
580    
581            public boolean isReverse() {
582                    return MathUtil.getBoolean(get("reverse"));
583            }
584    
585            public void setReverse(boolean reverse) {
586                    put("reverse", reverse);
587            }
588    
589            public String getName() {
590                    return StringUtil.getString(get("name"));
591            }
592    
593            public boolean isRunJBlasDenseDoubleMatrix2D() {
594                    return MathUtil.getBoolean(get("runJBlasDenseDoubleMatrix2D"));
595            }
596    
597            public void setRunJBlasDenseDoubleMatrix2D(boolean runJBlas) {
598                    put("runJBlasDenseDoubleMatrix2D", runJBlas);
599            }
600    
601            public void setUseJBlas(boolean use) {
602                    put("useJBlas", use);
603            }
604    
605            public boolean isUseJBlas() {
606                    return MathUtil.getBoolean(get("useJBlas"));
607            }
608    
609            public void setUseMTJ(boolean use) {
610                    put("useMTJ", use);
611            }
612    
613            public boolean isUseMTJ() {
614                    return MathUtil.getBoolean(get("useMTJ"));
615            }
616    
617            public void setUseOjalgo(boolean use) {
618                    put("useOjalgo", use);
619            }
620    
621            public boolean isUseOjalgo() {
622                    return MathUtil.getBoolean(get("useOjalgo"));
623            }
624    
625            public void setUseEJML(boolean use) {
626                    put("useEJML", use);
627            }
628    
629            public boolean isUseEJML() {
630                    return MathUtil.getBoolean(get("useEJML"));
631            }
632    
633            public boolean isUseBlockMatrixMultiply() {
634                    return MathUtil.getBoolean(get("useBlockMatrixMultiply"));
635            }
636    
637            public int getDefaultBlockSize() {
638                    return MathUtil.getInt(get("defaultBlockSize"));
639            }
640    
641            public void setUseBlockMatrixMultiply(boolean use) {
642                    put("useBlockMatrixMultiply", use);
643            }
644    
645            public void setDefaultBlockSize(int size) {
646                    put("defaultBlockSize", size);
647            }
648    
649            public void setUseParallelColt(boolean use) {
650                    put("useParallelColt", use);
651            }
652    
653            public boolean isUseParallelColt() {
654                    return MathUtil.getBoolean(get("useParallelColt"));
655            }
656    
657            public void setUseCommonsMath(boolean use) {
658                    put("useCommonsMath", use);
659            }
660    
661            public boolean isUseCommonsMath() {
662                    return MathUtil.getBoolean(get("useCommonsMath"));
663            }
664    
665            public void setName(String name) {
666                    put("name", name);
667            }
668    }