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.mapper;
025    
026    import java.lang.reflect.Constructor;
027    import java.util.logging.Level;
028    import java.util.logging.Logger;
029    
030    import org.ujmp.core.Matrix;
031    import org.ujmp.core.bigdecimalmatrix.impl.DefaultDenseBigDecimalMatrix2D;
032    import org.ujmp.core.bigdecimalmatrix.impl.DefaultSparseBigDecimalMatrix;
033    import org.ujmp.core.bigdecimalmatrix.stub.AbstractDenseBigDecimalMatrix;
034    import org.ujmp.core.bigdecimalmatrix.stub.AbstractDenseBigDecimalMatrix2D;
035    import org.ujmp.core.bigdecimalmatrix.stub.AbstractSparseBigDecimalMatrix;
036    import org.ujmp.core.bigdecimalmatrix.stub.AbstractSparseBigDecimalMatrix2D;
037    import org.ujmp.core.bigintegermatrix.impl.DefaultDenseBigIntegerMatrix2D;
038    import org.ujmp.core.bigintegermatrix.impl.DefaultSparseBigIntegerMatrix;
039    import org.ujmp.core.bigintegermatrix.stub.AbstractDenseBigIntegerMatrix;
040    import org.ujmp.core.bigintegermatrix.stub.AbstractDenseBigIntegerMatrix2D;
041    import org.ujmp.core.bigintegermatrix.stub.AbstractSparseBigIntegerMatrix;
042    import org.ujmp.core.bigintegermatrix.stub.AbstractSparseBigIntegerMatrix2D;
043    import org.ujmp.core.booleanmatrix.impl.DefaultDenseBooleanMatrix2D;
044    import org.ujmp.core.booleanmatrix.impl.DefaultSparseBooleanMatrix;
045    import org.ujmp.core.booleanmatrix.stub.AbstractDenseBooleanMatrix;
046    import org.ujmp.core.booleanmatrix.stub.AbstractDenseBooleanMatrix2D;
047    import org.ujmp.core.booleanmatrix.stub.AbstractSparseBooleanMatrix;
048    import org.ujmp.core.booleanmatrix.stub.AbstractSparseBooleanMatrix2D;
049    import org.ujmp.core.bytematrix.impl.ArrayDenseByteMatrix2D;
050    import org.ujmp.core.bytematrix.impl.DefaultSparseByteMatrix;
051    import org.ujmp.core.bytematrix.stub.AbstractDenseByteMatrix;
052    import org.ujmp.core.bytematrix.stub.AbstractDenseByteMatrix2D;
053    import org.ujmp.core.bytematrix.stub.AbstractSparseByteMatrix;
054    import org.ujmp.core.bytematrix.stub.AbstractSparseByteMatrix2D;
055    import org.ujmp.core.charmatrix.impl.ArrayDenseCharMatrix2D;
056    import org.ujmp.core.charmatrix.impl.DefaultSparseCharMatrix;
057    import org.ujmp.core.charmatrix.stub.AbstractDenseCharMatrix;
058    import org.ujmp.core.charmatrix.stub.AbstractDenseCharMatrix2D;
059    import org.ujmp.core.charmatrix.stub.AbstractSparseCharMatrix;
060    import org.ujmp.core.charmatrix.stub.AbstractSparseCharMatrix2D;
061    import org.ujmp.core.datematrix.impl.DefaultDenseDateMatrix2D;
062    import org.ujmp.core.datematrix.impl.DefaultSparseDateMatrix;
063    import org.ujmp.core.datematrix.stub.AbstractDenseDateMatrix;
064    import org.ujmp.core.datematrix.stub.AbstractDenseDateMatrix2D;
065    import org.ujmp.core.datematrix.stub.AbstractSparseDateMatrix;
066    import org.ujmp.core.datematrix.stub.AbstractSparseDateMatrix2D;
067    import org.ujmp.core.doublematrix.impl.DefaultSparseDoubleMatrix;
068    import org.ujmp.core.doublematrix.stub.AbstractSparseDoubleMatrix;
069    import org.ujmp.core.doublematrix.stub.AbstractSparseDoubleMatrix2D;
070    import org.ujmp.core.floatmatrix.impl.ArrayDenseFloatMatrix2D;
071    import org.ujmp.core.floatmatrix.impl.DefaultSparseFloatMatrix;
072    import org.ujmp.core.floatmatrix.stub.AbstractDenseFloatMatrix;
073    import org.ujmp.core.floatmatrix.stub.AbstractDenseFloatMatrix2D;
074    import org.ujmp.core.floatmatrix.stub.AbstractSparseFloatMatrix;
075    import org.ujmp.core.floatmatrix.stub.AbstractSparseFloatMatrix2D;
076    import org.ujmp.core.intmatrix.impl.DefaultDenseIntMatrix2D;
077    import org.ujmp.core.intmatrix.impl.DefaultSparseIntMatrix;
078    import org.ujmp.core.intmatrix.stub.AbstractDenseIntMatrix;
079    import org.ujmp.core.intmatrix.stub.AbstractDenseIntMatrix2D;
080    import org.ujmp.core.intmatrix.stub.AbstractSparseIntMatrix;
081    import org.ujmp.core.intmatrix.stub.AbstractSparseIntMatrix2D;
082    import org.ujmp.core.longmatrix.impl.DefaultDenseLongMatrix2D;
083    import org.ujmp.core.longmatrix.impl.DefaultSparseLongMatrix;
084    import org.ujmp.core.longmatrix.stub.AbstractDenseLongMatrix;
085    import org.ujmp.core.longmatrix.stub.AbstractDenseLongMatrix2D;
086    import org.ujmp.core.longmatrix.stub.AbstractSparseLongMatrix;
087    import org.ujmp.core.longmatrix.stub.AbstractSparseLongMatrix2D;
088    import org.ujmp.core.mapmatrix.DefaultMapMatrix;
089    import org.ujmp.core.mapmatrix.MapMatrix;
090    import org.ujmp.core.objectmatrix.impl.DefaultDenseObjectMatrix2D;
091    import org.ujmp.core.objectmatrix.impl.DefaultSparseObjectMatrix;
092    import org.ujmp.core.objectmatrix.stub.AbstractDenseObjectMatrix;
093    import org.ujmp.core.objectmatrix.stub.AbstractDenseObjectMatrix2D;
094    import org.ujmp.core.objectmatrix.stub.AbstractSparseObjectMatrix;
095    import org.ujmp.core.objectmatrix.stub.AbstractSparseObjectMatrix2D;
096    import org.ujmp.core.shortmatrix.impl.DefaultDenseShortMatrix2D;
097    import org.ujmp.core.shortmatrix.impl.DefaultSparseShortMatrix;
098    import org.ujmp.core.shortmatrix.stub.AbstractDenseShortMatrix;
099    import org.ujmp.core.shortmatrix.stub.AbstractDenseShortMatrix2D;
100    import org.ujmp.core.shortmatrix.stub.AbstractSparseShortMatrix;
101    import org.ujmp.core.shortmatrix.stub.AbstractSparseShortMatrix2D;
102    import org.ujmp.core.stringmatrix.impl.DefaultDenseStringMatrix2D;
103    import org.ujmp.core.stringmatrix.impl.DefaultSparseStringMatrix;
104    import org.ujmp.core.stringmatrix.stub.AbstractDenseStringMatrix;
105    import org.ujmp.core.stringmatrix.stub.AbstractDenseStringMatrix2D;
106    import org.ujmp.core.stringmatrix.stub.AbstractSparseStringMatrix;
107    import org.ujmp.core.stringmatrix.stub.AbstractSparseStringMatrix2D;
108    
109    public class MatrixMapper implements ClassMapper {
110    
111            private transient static final Logger logger = Logger.getLogger(MatrixMapper.class.getName());
112    
113            private static final Class<?>[] LONGARRAY = new Class<?>[] { new long[] {}.getClass() };
114    
115            private final MapMatrix<Class<? extends Matrix>, String> matrixClasses = new DefaultMapMatrix<Class<? extends Matrix>, String>();
116    
117            private Constructor<?> denseBooleanMatrix2DConstructor = null;
118    
119            private Constructor<?> denseByteMatrix2DConstructor = null;
120    
121            private Constructor<?> denseCharMatrix2DConstructor = null;
122    
123            private Constructor<?> denseDateMatrix2DConstructor = null;
124    
125            private Constructor<?> denseFloatMatrix2DConstructor = null;
126    
127            private Constructor<?> denseIntMatrix2DConstructor = null;
128    
129            private Constructor<?> denseLongMatrix2DConstructor = null;
130    
131            private Constructor<?> denseShortMatrix2DConstructor = null;
132    
133            private Constructor<?> denseObjectMatrix2DConstructor = null;
134    
135            private Constructor<?> denseStringMatrix2DConstructor = null;
136    
137            private Constructor<?> denseBooleanMatrixMultiDConstructor = null;
138    
139            private Constructor<?> denseByteMatrixMultiDConstructor = null;
140    
141            private Constructor<?> denseCharMatrixMultiDConstructor = null;
142    
143            private Constructor<?> denseDateMatrixMultiDConstructor = null;
144    
145            private Constructor<?> denseFloatMatrixMultiDConstructor = null;
146    
147            private Constructor<?> denseIntMatrixMultiDConstructor = null;
148    
149            private Constructor<?> denseLongMatrixMultiDConstructor = null;
150    
151            private Constructor<?> denseShortMatrixMultiDConstructor = null;
152    
153            private Constructor<?> denseObjectMatrixMultiDConstructor = null;
154    
155            private Constructor<?> denseStringMatrixMultiDConstructor = null;
156    
157            private Constructor<?> denseBigIntegerMatrixMultiDConstructor = null;
158    
159            private Constructor<?> denseBigDecimalMatrixMultiDConstructor = null;
160    
161            private Constructor<?> sparseBooleanMatrix2DConstructor = null;
162    
163            private Constructor<?> sparseByteMatrix2DConstructor = null;
164    
165            private Constructor<?> sparseCharMatrix2DConstructor = null;
166    
167            private Constructor<?> sparseDateMatrix2DConstructor = null;
168    
169            private Constructor<?> sparseDoubleMatrix2DConstructor = null;
170    
171            private Constructor<?> sparseFloatMatrix2DConstructor = null;
172    
173            private Constructor<?> sparseIntMatrix2DConstructor = null;
174    
175            private Constructor<?> sparseLongMatrix2DConstructor = null;
176    
177            private Constructor<?> sparseShortMatrix2DConstructor = null;
178    
179            private Constructor<?> sparseObjectMatrix2DConstructor = null;
180    
181            private Constructor<?> sparseStringMatrix2DConstructor = null;
182    
183            private Constructor<?> sparseBooleanMatrixMultiDConstructor = null;
184    
185            private Constructor<?> sparseByteMatrixMultiDConstructor = null;
186    
187            private Constructor<?> sparseCharMatrixMultiDConstructor = null;
188    
189            private Constructor<?> sparseDateMatrixMultiDConstructor = null;
190    
191            private Constructor<?> sparseDoubleMatrixMultiDConstructor = null;
192    
193            private Constructor<?> sparseFloatMatrixMultiDConstructor = null;
194    
195            private Constructor<?> sparseIntMatrixMultiDConstructor = null;
196    
197            private Constructor<?> sparseLongMatrixMultiDConstructor = null;
198    
199            private Constructor<?> sparseShortMatrixMultiDConstructor = null;
200    
201            private Constructor<?> sparseObjectMatrixMultiDConstructor = null;
202    
203            private Constructor<?> sparseStringMatrixMultiDConstructor = null;
204    
205            private Constructor<?> sparseBigIntegerMatrixMultiDConstructor = null;
206    
207            private Constructor<?> sparseBigIntegerMatrix2DConstructor = null;
208    
209            private Constructor<?> denseBigIntegerMatrix2DConstructor = null;
210    
211            private Constructor<?> sparseBigDecimalMatrixMultiDConstructor = null;
212    
213            private Constructor<?> sparseBigDecimalMatrix2DConstructor = null;
214    
215            private Constructor<?> denseBigDecimalMatrix2DConstructor = null;
216    
217            private static MatrixMapper instance = null;
218    
219            public static MatrixMapper getInstance() {
220                    if (instance == null) {
221                            instance = new MatrixMapper();
222                    }
223                    return instance;
224            }
225    
226            private MatrixMapper() {
227                    findMatrixClasses();
228            }
229    
230            private void findMatrixClasses() {
231                    try {
232                            setDenseBooleanMatrix2DClassName(DefaultDenseBooleanMatrix2D.class.getName());
233                            setDenseBooleanMatrixMultiDClassName(DefaultSparseBooleanMatrix.class.getName());
234                            setSparseBooleanMatrix2DClassName(DefaultSparseBooleanMatrix.class.getName());
235                            setSparseBooleanMatrixMultiDClassName(DefaultSparseBooleanMatrix.class.getName());
236    
237                            setDenseByteMatrix2DClassName(ArrayDenseByteMatrix2D.class.getName());
238                            setDenseByteMatrixMultiDClassName(DefaultSparseByteMatrix.class.getName());
239                            setSparseByteMatrix2DClassName(DefaultSparseByteMatrix.class.getName());
240                            setSparseByteMatrixMultiDClassName(DefaultSparseByteMatrix.class.getName());
241    
242                            setDenseCharMatrix2DClassName(ArrayDenseCharMatrix2D.class.getName());
243                            setDenseCharMatrixMultiDClassName(DefaultSparseCharMatrix.class.getName());
244                            setSparseCharMatrix2DClassName(DefaultSparseCharMatrix.class.getName());
245                            setSparseCharMatrixMultiDClassName(DefaultSparseCharMatrix.class.getName());
246    
247                            setDenseDateMatrix2DClassName(DefaultDenseDateMatrix2D.class.getName());
248                            setDenseDateMatrixMultiDClassName(DefaultSparseDateMatrix.class.getName());
249                            setSparseDateMatrix2DClassName(DefaultSparseDateMatrix.class.getName());
250                            setSparseDateMatrixMultiDClassName(DefaultSparseDateMatrix.class.getName());
251    
252                            setSparseDoubleMatrix2DClassName(DefaultSparseDoubleMatrix.class.getName());
253                            setSparseDoubleMatrixMultiDClassName(DefaultSparseDoubleMatrix.class.getName());
254    
255                            setDenseFloatMatrix2DClassName(ArrayDenseFloatMatrix2D.class.getName());
256                            setDenseFloatMatrixMultiDClassName(DefaultSparseFloatMatrix.class.getName());
257                            setSparseFloatMatrix2DClassName(DefaultSparseFloatMatrix.class.getName());
258                            setSparseFloatMatrixMultiDClassName(DefaultSparseFloatMatrix.class.getName());
259    
260                            setDenseIntMatrix2DClassName(DefaultDenseIntMatrix2D.class.getName());
261                            setDenseIntMatrixMultiDClassName(DefaultSparseIntMatrix.class.getName());
262                            setSparseIntMatrix2DClassName(DefaultSparseIntMatrix.class.getName());
263                            setSparseIntMatrixMultiDClassName(DefaultSparseIntMatrix.class.getName());
264    
265                            setDenseLongMatrix2DClassName(DefaultDenseLongMatrix2D.class.getName());
266                            setDenseLongMatrixMultiDClassName(DefaultSparseLongMatrix.class.getName());
267                            setSparseLongMatrix2DClassName(DefaultSparseLongMatrix.class.getName());
268                            setSparseLongMatrixMultiDClassName(DefaultSparseLongMatrix.class.getName());
269    
270                            setDenseObjectMatrix2DClassName(DefaultDenseObjectMatrix2D.class.getName());
271                            setDenseObjectMatrixMultiDClassName(DefaultSparseObjectMatrix.class.getName());
272                            setSparseObjectMatrix2DClassName(DefaultSparseObjectMatrix.class.getName());
273                            setSparseObjectMatrixMultiDClassName(DefaultSparseObjectMatrix.class.getName());
274    
275                            setDenseShortMatrix2DClassName(DefaultDenseShortMatrix2D.class.getName());
276                            setDenseShortMatrixMultiDClassName(DefaultSparseShortMatrix.class.getName());
277                            setSparseShortMatrix2DClassName(DefaultSparseShortMatrix.class.getName());
278                            setSparseShortMatrixMultiDClassName(DefaultSparseShortMatrix.class.getName());
279    
280                            setDenseStringMatrix2DClassName(DefaultDenseStringMatrix2D.class.getName());
281                            setDenseStringMatrixMultiDClassName(DefaultSparseStringMatrix.class.getName());
282                            setSparseStringMatrix2DClassName(DefaultSparseStringMatrix.class.getName());
283                            setSparseStringMatrixMultiDClassName(DefaultSparseStringMatrix.class.getName());
284    
285                            setDenseBigIntegerMatrix2DClassName(DefaultDenseBigIntegerMatrix2D.class.getName());
286                            setDenseBigIntegerMatrixMultiDClassName(DefaultSparseBigIntegerMatrix.class.getName());
287                            setSparseBigIntegerMatrix2DClassName(DefaultSparseBigIntegerMatrix.class.getName());
288                            setSparseBigIntegerMatrixMultiDClassName(DefaultSparseBigIntegerMatrix.class.getName());
289    
290                            setDenseBigDecimalMatrix2DClassName(DefaultDenseBigDecimalMatrix2D.class.getName());
291                            setDenseBigDecimalMatrixMultiDClassName(DefaultSparseBigDecimalMatrix.class.getName());
292                            setSparseBigDecimalMatrix2DClassName(DefaultSparseBigDecimalMatrix.class.getName());
293                            setSparseBigDecimalMatrixMultiDClassName(DefaultSparseBigDecimalMatrix.class.getName());
294    
295                    } catch (Exception e) {
296                            logger.log(Level.SEVERE, "Default Matrix classes not found, this should never happen",
297                                            e);
298                    }
299            }
300    
301            public void setSparseDoubleMatrix2DClassName(String className) throws Exception {
302                    matrixClasses.put(AbstractSparseDoubleMatrix2D.class, className);
303                    Class<?> matrixClass = null;
304                    try {
305                            matrixClass = Class.forName(className);
306                    } catch (ClassNotFoundException e) {
307                            matrixClass = DefaultSparseDoubleMatrix.class;
308                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
309                                            + " instead.");
310                    }
311                    sparseDoubleMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
312            }
313    
314            public void setSparseDoubleMatrixMultiDClassName(String className) throws Exception {
315                    matrixClasses.put(AbstractSparseDoubleMatrix.class, className);
316                    Class<?> matrixClass = null;
317                    try {
318                            matrixClass = Class.forName(className);
319                    } catch (ClassNotFoundException e) {
320                            matrixClass = DefaultSparseDoubleMatrix.class;
321                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
322                                            + " instead.");
323                    }
324                    sparseDoubleMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
325            }
326    
327            public void setDenseBooleanMatrix2DClassName(String className) throws Exception {
328                    matrixClasses.put(AbstractDenseBooleanMatrix2D.class, className);
329                    Class<?> matrixClass = null;
330                    try {
331                            matrixClass = Class.forName(className);
332                    } catch (ClassNotFoundException e) {
333                            matrixClass = DefaultDenseBooleanMatrix2D.class;
334                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
335                                            + " instead.");
336                    }
337                    denseBooleanMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
338            }
339    
340            public void setDenseBooleanMatrixMultiDClassName(String className) throws Exception {
341                    matrixClasses.put(AbstractDenseBooleanMatrix.class, className);
342                    Class<?> matrixClass = null;
343                    try {
344                            matrixClass = Class.forName(className);
345                    } catch (ClassNotFoundException e) {
346                            matrixClass = DefaultSparseBooleanMatrix.class;
347                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
348                                            + " instead.");
349                    }
350                    denseBooleanMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
351            }
352    
353            public void setSparseBooleanMatrix2DClassName(String className) throws Exception {
354                    matrixClasses.put(AbstractSparseBooleanMatrix2D.class, className);
355                    Class<?> matrixClass = null;
356                    try {
357                            matrixClass = Class.forName(className);
358                    } catch (ClassNotFoundException e) {
359                            matrixClass = DefaultSparseBooleanMatrix.class;
360                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
361                                            + " instead.");
362                    }
363                    sparseBooleanMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
364            }
365    
366            public void setSparseBooleanMatrixMultiDClassName(String className) throws Exception {
367                    matrixClasses.put(AbstractSparseBooleanMatrix.class, className);
368                    Class<?> matrixClass = null;
369                    try {
370                            matrixClass = Class.forName(className);
371                    } catch (ClassNotFoundException e) {
372                            matrixClass = DefaultSparseBooleanMatrix.class;
373                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
374                                            + " instead.");
375                    }
376                    sparseBooleanMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
377            }
378    
379            public void setDenseFloatMatrix2DClassName(String className) throws Exception {
380                    matrixClasses.put(AbstractDenseFloatMatrix2D.class, className);
381                    Class<?> matrixClass = null;
382                    try {
383                            matrixClass = Class.forName(className);
384                    } catch (ClassNotFoundException e) {
385                            matrixClass = ArrayDenseFloatMatrix2D.class;
386                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
387                                            + " instead.");
388                    }
389                    denseFloatMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
390            }
391    
392            public void setDenseFloatMatrixMultiDClassName(String className) throws Exception {
393                    matrixClasses.put(AbstractDenseFloatMatrix.class, className);
394                    Class<?> matrixClass = null;
395                    try {
396                            matrixClass = Class.forName(className);
397                    } catch (ClassNotFoundException e) {
398                            matrixClass = DefaultSparseFloatMatrix.class;
399                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
400                                            + " instead.");
401                    }
402                    denseFloatMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
403            }
404    
405            public void setSparseFloatMatrix2DClassName(String className) throws Exception {
406                    matrixClasses.put(AbstractSparseFloatMatrix2D.class, className);
407                    Class<?> matrixClass = null;
408                    try {
409                            matrixClass = Class.forName(className);
410                    } catch (ClassNotFoundException e) {
411                            matrixClass = DefaultSparseFloatMatrix.class;
412                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
413                                            + " instead.");
414                    }
415                    sparseFloatMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
416            }
417    
418            public void setSparseFloatMatrixMultiDClassName(String className) throws Exception {
419                    matrixClasses.put(AbstractSparseFloatMatrix.class, className);
420                    Class<?> matrixClass = null;
421                    try {
422                            matrixClass = Class.forName(className);
423                    } catch (ClassNotFoundException e) {
424                            matrixClass = DefaultSparseFloatMatrix.class;
425                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
426                                            + " instead.");
427                    }
428                    sparseFloatMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
429            }
430    
431            public void setDenseIntMatrix2DClassName(String className) throws Exception {
432                    matrixClasses.put(AbstractDenseIntMatrix2D.class, className);
433                    Class<?> matrixClass = null;
434                    try {
435                            matrixClass = Class.forName(className);
436                    } catch (ClassNotFoundException e) {
437                            matrixClass = DefaultDenseIntMatrix2D.class;
438                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
439                                            + " instead.");
440                    }
441                    denseIntMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
442            }
443    
444            public void setDenseIntMatrixMultiDClassName(String className) throws Exception {
445                    matrixClasses.put(AbstractDenseIntMatrix.class, className);
446                    Class<?> matrixClass = null;
447                    try {
448                            matrixClass = Class.forName(className);
449                    } catch (ClassNotFoundException e) {
450                            matrixClass = DefaultSparseIntMatrix.class;
451                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
452                                            + " instead.");
453                    }
454                    denseIntMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
455            }
456    
457            public void setSparseIntMatrix2DClassName(String className) throws Exception {
458                    matrixClasses.put(AbstractSparseIntMatrix2D.class, className);
459                    Class<?> matrixClass = null;
460                    try {
461                            matrixClass = Class.forName(className);
462                    } catch (ClassNotFoundException e) {
463                            matrixClass = DefaultSparseIntMatrix.class;
464                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
465                                            + " instead.");
466                    }
467                    sparseIntMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
468            }
469    
470            public void setSparseIntMatrixMultiDClassName(String className) throws Exception {
471                    matrixClasses.put(AbstractSparseIntMatrix.class, className);
472                    Class<?> matrixClass = null;
473                    try {
474                            matrixClass = Class.forName(className);
475                    } catch (ClassNotFoundException e) {
476                            matrixClass = DefaultSparseIntMatrix.class;
477                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
478                                            + " instead.");
479                    }
480                    sparseIntMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
481            }
482    
483            public void setDenseShortMatrix2DClassName(String className) throws Exception {
484                    matrixClasses.put(AbstractDenseShortMatrix2D.class, className);
485                    Class<?> matrixClass = null;
486                    try {
487                            matrixClass = Class.forName(className);
488                    } catch (ClassNotFoundException e) {
489                            matrixClass = DefaultDenseShortMatrix2D.class;
490                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
491                                            + " instead.");
492                    }
493                    denseShortMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
494            }
495    
496            public void setDenseShortMatrixMultiDClassName(String className) throws Exception {
497                    matrixClasses.put(AbstractDenseShortMatrix.class, className);
498                    Class<?> matrixClass = null;
499                    try {
500                            matrixClass = Class.forName(className);
501                    } catch (ClassNotFoundException e) {
502                            matrixClass = DefaultSparseShortMatrix.class;
503                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
504                                            + " instead.");
505                    }
506                    denseShortMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
507            }
508    
509            public void setSparseShortMatrix2DClassName(String className) throws Exception {
510                    matrixClasses.put(AbstractSparseShortMatrix2D.class, className);
511                    Class<?> matrixClass = null;
512                    try {
513                            matrixClass = Class.forName(className);
514                    } catch (ClassNotFoundException e) {
515                            matrixClass = DefaultSparseShortMatrix.class;
516                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
517                                            + " instead.");
518                    }
519                    sparseShortMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
520            }
521    
522            public void setSparseShortMatrixMultiDClassName(String className) throws Exception {
523                    matrixClasses.put(AbstractSparseShortMatrix.class, className);
524                    Class<?> matrixClass = null;
525                    try {
526                            matrixClass = Class.forName(className);
527                    } catch (ClassNotFoundException e) {
528                            matrixClass = DefaultSparseShortMatrix.class;
529                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
530                                            + " instead.");
531                    }
532                    sparseShortMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
533            }
534    
535            public void setDenseLongMatrix2DClassName(String className) throws Exception {
536                    matrixClasses.put(AbstractDenseLongMatrix2D.class, className);
537                    Class<?> matrixClass = null;
538                    try {
539                            matrixClass = Class.forName(className);
540                    } catch (ClassNotFoundException e) {
541                            matrixClass = DefaultDenseLongMatrix2D.class;
542                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
543                                            + " instead.");
544                    }
545                    denseLongMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
546            }
547    
548            public void setDenseLongMatrixMultiDClassName(String className) throws Exception {
549                    matrixClasses.put(AbstractDenseLongMatrix.class, className);
550                    Class<?> matrixClass = null;
551                    try {
552                            matrixClass = Class.forName(className);
553                    } catch (ClassNotFoundException e) {
554                            matrixClass = DefaultSparseLongMatrix.class;
555                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
556                                            + " instead.");
557                    }
558                    denseLongMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
559            }
560    
561            public void setSparseLongMatrix2DClassName(String className) throws Exception {
562                    matrixClasses.put(AbstractSparseLongMatrix2D.class, className);
563                    Class<?> matrixClass = null;
564                    try {
565                            matrixClass = Class.forName(className);
566                    } catch (ClassNotFoundException e) {
567                            matrixClass = DefaultSparseLongMatrix.class;
568                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
569                                            + " instead.");
570                    }
571                    sparseLongMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
572            }
573    
574            public void setSparseLongMatrixMultiDClassName(String className) throws Exception {
575                    matrixClasses.put(AbstractSparseLongMatrix.class, className);
576                    Class<?> matrixClass = null;
577                    try {
578                            matrixClass = Class.forName(className);
579                    } catch (ClassNotFoundException e) {
580                            matrixClass = DefaultSparseLongMatrix.class;
581                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
582                                            + " instead.");
583                    }
584                    sparseLongMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
585            }
586    
587            public void setDenseByteMatrix2DClassName(String className) throws Exception {
588                    matrixClasses.put(AbstractDenseByteMatrix2D.class, className);
589                    Class<?> matrixClass = null;
590                    try {
591                            matrixClass = Class.forName(className);
592                    } catch (ClassNotFoundException e) {
593                            matrixClass = ArrayDenseByteMatrix2D.class;
594                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
595                                            + " instead.");
596                    }
597                    denseByteMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
598            }
599    
600            public void setDenseByteMatrixMultiDClassName(String className) throws Exception {
601                    matrixClasses.put(AbstractDenseByteMatrix.class, className);
602                    Class<?> matrixClass = null;
603                    try {
604                            matrixClass = Class.forName(className);
605                    } catch (ClassNotFoundException e) {
606                            matrixClass = DefaultSparseByteMatrix.class;
607                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
608                                            + " instead.");
609                    }
610                    denseByteMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
611            }
612    
613            public void setSparseByteMatrix2DClassName(String className) throws Exception {
614                    matrixClasses.put(AbstractSparseByteMatrix2D.class, className);
615                    Class<?> matrixClass = null;
616                    try {
617                            matrixClass = Class.forName(className);
618                    } catch (ClassNotFoundException e) {
619                            matrixClass = DefaultSparseByteMatrix.class;
620                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
621                                            + " instead.");
622                    }
623                    sparseByteMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
624            }
625    
626            public void setSparseByteMatrixMultiDClassName(String className) throws Exception {
627                    matrixClasses.put(AbstractSparseByteMatrix.class, className);
628                    Class<?> matrixClass = null;
629                    try {
630                            matrixClass = Class.forName(className);
631                    } catch (ClassNotFoundException e) {
632                            matrixClass = DefaultSparseByteMatrix.class;
633                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
634                                            + " instead.");
635                    }
636                    sparseByteMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
637            }
638    
639            public void setDenseCharMatrix2DClassName(String className) throws Exception {
640                    matrixClasses.put(AbstractDenseCharMatrix2D.class, className);
641                    Class<?> matrixClass = null;
642                    try {
643                            matrixClass = Class.forName(className);
644                    } catch (ClassNotFoundException e) {
645                            matrixClass = ArrayDenseCharMatrix2D.class;
646                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
647                                            + " instead.");
648                    }
649                    denseCharMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
650            }
651    
652            public void setDenseCharMatrixMultiDClassName(String className) throws Exception {
653                    matrixClasses.put(AbstractDenseCharMatrix.class, className);
654                    Class<?> matrixClass = null;
655                    try {
656                            matrixClass = Class.forName(className);
657                    } catch (ClassNotFoundException e) {
658                            matrixClass = DefaultSparseCharMatrix.class;
659                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
660                                            + " instead.");
661                    }
662                    denseCharMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
663            }
664    
665            public void setSparseCharMatrix2DClassName(String className) throws Exception {
666                    matrixClasses.put(AbstractSparseCharMatrix2D.class, className);
667                    Class<?> matrixClass = null;
668                    try {
669                            matrixClass = Class.forName(className);
670                    } catch (ClassNotFoundException e) {
671                            matrixClass = DefaultSparseCharMatrix.class;
672                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
673                                            + " instead.");
674                    }
675                    sparseCharMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
676            }
677    
678            public void setSparseCharMatrixMultiDClassName(String className) throws Exception {
679                    matrixClasses.put(AbstractSparseCharMatrix.class, className);
680                    Class<?> matrixClass = null;
681                    try {
682                            matrixClass = Class.forName(className);
683                    } catch (ClassNotFoundException e) {
684                            matrixClass = DefaultSparseCharMatrix.class;
685                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
686                                            + " instead.");
687                    }
688                    sparseCharMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
689            }
690    
691            public void setDenseDateMatrix2DClassName(String className) throws Exception {
692                    matrixClasses.put(AbstractDenseDateMatrix2D.class, className);
693                    Class<?> matrixClass = null;
694                    try {
695                            matrixClass = Class.forName(className);
696                    } catch (ClassNotFoundException e) {
697                            matrixClass = DefaultDenseDateMatrix2D.class;
698                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
699                                            + " instead.");
700                    }
701                    denseDateMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
702            }
703    
704            public void setDenseDateMatrixMultiDClassName(String className) throws Exception {
705                    matrixClasses.put(AbstractDenseDateMatrix.class, className);
706                    Class<?> matrixClass = null;
707                    try {
708                            matrixClass = Class.forName(className);
709                    } catch (ClassNotFoundException e) {
710                            matrixClass = DefaultSparseDateMatrix.class;
711                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
712                                            + " instead.");
713                    }
714                    denseDateMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
715            }
716    
717            public void setSparseDateMatrix2DClassName(String className) throws Exception {
718                    matrixClasses.put(AbstractSparseDateMatrix2D.class, className);
719                    Class<?> matrixClass = null;
720                    try {
721                            matrixClass = Class.forName(className);
722                    } catch (ClassNotFoundException e) {
723                            matrixClass = DefaultSparseDateMatrix.class;
724                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
725                                            + " instead.");
726                    }
727                    sparseDateMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
728            }
729    
730            public void setSparseDateMatrixMultiDClassName(String className) throws Exception {
731                    matrixClasses.put(AbstractSparseDateMatrix.class, className);
732                    Class<?> matrixClass = null;
733                    try {
734                            matrixClass = Class.forName(className);
735                    } catch (ClassNotFoundException e) {
736                            matrixClass = DefaultSparseDateMatrix.class;
737                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
738                                            + " instead.");
739                    }
740                    sparseDateMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
741            }
742    
743            public void setDenseStringMatrix2DClassName(String className) throws Exception {
744                    matrixClasses.put(AbstractDenseStringMatrix2D.class, className);
745                    Class<?> matrixClass = null;
746                    try {
747                            matrixClass = Class.forName(className);
748                    } catch (ClassNotFoundException e) {
749                            matrixClass = DefaultDenseStringMatrix2D.class;
750                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
751                                            + " instead.");
752                    }
753                    denseStringMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
754            }
755    
756            public void setDenseBigIntegerMatrix2DClassName(String className) throws Exception {
757                    matrixClasses.put(AbstractDenseBigIntegerMatrix2D.class, className);
758                    Class<?> matrixClass = null;
759                    try {
760                            matrixClass = Class.forName(className);
761                    } catch (ClassNotFoundException e) {
762                            matrixClass = DefaultDenseBigIntegerMatrix2D.class;
763                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
764                                            + " instead.");
765                    }
766                    denseBigIntegerMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
767            }
768    
769            public void setDenseBigDecimalMatrix2DClassName(String className) throws Exception {
770                    matrixClasses.put(AbstractDenseBigDecimalMatrix2D.class, className);
771                    Class<?> matrixClass = null;
772                    try {
773                            matrixClass = Class.forName(className);
774                    } catch (ClassNotFoundException e) {
775                            matrixClass = DefaultDenseBigDecimalMatrix2D.class;
776                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
777                                            + " instead.");
778                    }
779                    denseBigDecimalMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
780            }
781    
782            public void setDenseStringMatrixMultiDClassName(String className) throws Exception {
783                    matrixClasses.put(AbstractDenseStringMatrix.class, className);
784                    Class<?> matrixClass = null;
785                    try {
786                            matrixClass = Class.forName(className);
787                    } catch (ClassNotFoundException e) {
788                            matrixClass = DefaultSparseStringMatrix.class;
789                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
790                                            + " instead.");
791                    }
792                    denseStringMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
793            }
794    
795            public void setDenseBigIntegerMatrixMultiDClassName(String className) throws Exception {
796                    matrixClasses.put(AbstractDenseBigIntegerMatrix.class, className);
797                    Class<?> matrixClass = null;
798                    try {
799                            matrixClass = Class.forName(className);
800                    } catch (ClassNotFoundException e) {
801                            matrixClass = DefaultSparseBigIntegerMatrix.class;
802                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
803                                            + " instead.");
804                    }
805                    denseBigIntegerMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
806            }
807    
808            public void setDenseBigDecimalMatrixMultiDClassName(String className) throws Exception {
809                    matrixClasses.put(AbstractDenseBigDecimalMatrix.class, className);
810                    Class<?> matrixClass = null;
811                    try {
812                            matrixClass = Class.forName(className);
813                    } catch (ClassNotFoundException e) {
814                            matrixClass = DefaultSparseBigDecimalMatrix.class;
815                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
816                                            + " instead.");
817                    }
818                    denseBigDecimalMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
819            }
820    
821            public void setSparseStringMatrix2DClassName(String className) throws Exception {
822                    matrixClasses.put(AbstractSparseStringMatrix2D.class, className);
823                    Class<?> matrixClass = null;
824                    try {
825                            matrixClass = Class.forName(className);
826                    } catch (ClassNotFoundException e) {
827                            matrixClass = DefaultSparseStringMatrix.class;
828                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
829                                            + " instead.");
830                    }
831                    sparseStringMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
832            }
833    
834            public void setSparseBigIntegerMatrix2DClassName(String className) throws Exception {
835                    matrixClasses.put(AbstractSparseBigIntegerMatrix2D.class, className);
836                    Class<?> matrixClass = null;
837                    try {
838                            matrixClass = Class.forName(className);
839                    } catch (ClassNotFoundException e) {
840                            matrixClass = DefaultSparseBigIntegerMatrix.class;
841                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
842                                            + " instead.");
843                    }
844                    sparseBigIntegerMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
845            }
846    
847            public void setSparseBigDecimalMatrix2DClassName(String className) throws Exception {
848                    matrixClasses.put(AbstractSparseBigDecimalMatrix2D.class, className);
849                    Class<?> matrixClass = null;
850                    try {
851                            matrixClass = Class.forName(className);
852                    } catch (ClassNotFoundException e) {
853                            matrixClass = DefaultSparseBigDecimalMatrix.class;
854                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
855                                            + " instead.");
856                    }
857                    sparseBigDecimalMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
858            }
859    
860            public void setSparseStringMatrixMultiDClassName(String className) throws Exception {
861                    matrixClasses.put(AbstractSparseStringMatrix.class, className);
862                    Class<?> matrixClass = null;
863                    try {
864                            matrixClass = Class.forName(className);
865                    } catch (ClassNotFoundException e) {
866                            matrixClass = DefaultSparseStringMatrix.class;
867                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
868                                            + " instead.");
869                    }
870                    sparseStringMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
871            }
872    
873            public void setSparseBigIntegerMatrixMultiDClassName(String className) throws Exception {
874                    matrixClasses.put(AbstractSparseBigIntegerMatrix.class, className);
875                    Class<?> matrixClass = null;
876                    try {
877                            matrixClass = Class.forName(className);
878                    } catch (ClassNotFoundException e) {
879                            matrixClass = DefaultSparseBigIntegerMatrix.class;
880                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
881                                            + " instead.");
882                    }
883                    sparseBigIntegerMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
884            }
885    
886            public void setSparseBigDecimalMatrixMultiDClassName(String className) throws Exception {
887                    matrixClasses.put(AbstractSparseBigDecimalMatrix.class, className);
888                    Class<?> matrixClass = null;
889                    try {
890                            matrixClass = Class.forName(className);
891                    } catch (ClassNotFoundException e) {
892                            matrixClass = DefaultSparseBigDecimalMatrix.class;
893                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
894                                            + " instead.");
895                    }
896                    sparseBigDecimalMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
897            }
898    
899            public void setDenseObjectMatrix2DClassName(String className) throws Exception {
900                    matrixClasses.put(AbstractDenseObjectMatrix2D.class, className);
901                    Class<?> matrixClass = null;
902                    try {
903                            matrixClass = Class.forName(className);
904                    } catch (ClassNotFoundException e) {
905                            matrixClass = DefaultDenseObjectMatrix2D.class;
906                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
907                                            + " instead.");
908                    }
909                    denseObjectMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
910            }
911    
912            public void setDenseObjectMatrixMultiDClassName(String className) throws Exception {
913                    matrixClasses.put(AbstractDenseObjectMatrix.class, className);
914                    Class<?> matrixClass = null;
915                    try {
916                            matrixClass = Class.forName(className);
917                    } catch (ClassNotFoundException e) {
918                            matrixClass = DefaultSparseObjectMatrix.class;
919                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
920                                            + " instead.");
921                    }
922                    denseObjectMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
923            }
924    
925            public void setSparseObjectMatrix2DClassName(String className) throws Exception {
926                    matrixClasses.put(AbstractSparseObjectMatrix2D.class, className);
927                    Class<?> matrixClass = null;
928                    try {
929                            matrixClass = Class.forName(className);
930                    } catch (ClassNotFoundException e) {
931                            matrixClass = DefaultSparseObjectMatrix.class;
932                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
933                                            + " instead.");
934                    }
935                    sparseObjectMatrix2DConstructor = matrixClass.getConstructor(LONGARRAY);
936            }
937    
938            public void setSparseObjectMatrixMultiDClassName(String className) throws Exception {
939                    matrixClasses.put(AbstractSparseObjectMatrix.class, className);
940                    Class<?> matrixClass = null;
941                    try {
942                            matrixClass = Class.forName(className);
943                    } catch (ClassNotFoundException e) {
944                            matrixClass = DefaultSparseObjectMatrix.class;
945                            logger.log(Level.WARNING, "Could not find " + className + ", using " + matrixClass
946                                            + " instead.");
947                    }
948                    sparseObjectMatrixMultiDConstructor = matrixClass.getConstructor(LONGARRAY);
949            }
950    
951            public MapMatrix<Class<? extends Matrix>, String> getMatrixClasses() {
952                    return matrixClasses;
953            }
954    
955            public Constructor<?> getDenseBooleanMatrix2DConstructor() {
956                    return denseBooleanMatrix2DConstructor;
957            }
958    
959            public Constructor<?> getDenseByteMatrix2DConstructor() {
960                    return denseByteMatrix2DConstructor;
961            }
962    
963            public Constructor<?> getDenseCharMatrix2DConstructor() {
964                    return denseCharMatrix2DConstructor;
965            }
966    
967            public Constructor<?> getDenseDateMatrix2DConstructor() {
968                    return denseDateMatrix2DConstructor;
969            }
970    
971            public Constructor<?> getDenseFloatMatrix2DConstructor() {
972                    return denseFloatMatrix2DConstructor;
973            }
974    
975            public Constructor<?> getDenseIntMatrix2DConstructor() {
976                    return denseIntMatrix2DConstructor;
977            }
978    
979            public Constructor<?> getDenseLongMatrix2DConstructor() {
980                    return denseLongMatrix2DConstructor;
981            }
982    
983            public Constructor<?> getDenseShortMatrix2DConstructor() {
984                    return denseShortMatrix2DConstructor;
985            }
986    
987            public Constructor<?> getDenseObjectMatrix2DConstructor() {
988                    return denseObjectMatrix2DConstructor;
989            }
990    
991            public Constructor<?> getDenseStringMatrix2DConstructor() {
992                    return denseStringMatrix2DConstructor;
993            }
994    
995            public Constructor<?> getDenseBooleanMatrixMultiDConstructor() {
996                    return denseBooleanMatrixMultiDConstructor;
997            }
998    
999            public Constructor<?> getDenseByteMatrixMultiDConstructor() {
1000                    return denseByteMatrixMultiDConstructor;
1001            }
1002    
1003            public Constructor<?> getDenseCharMatrixMultiDConstructor() {
1004                    return denseCharMatrixMultiDConstructor;
1005            }
1006    
1007            public Constructor<?> getDenseDateMatrixMultiDConstructor() {
1008                    return denseDateMatrixMultiDConstructor;
1009            }
1010    
1011            public Constructor<?> getDenseFloatMatrixMultiDConstructor() {
1012                    return denseFloatMatrixMultiDConstructor;
1013            }
1014    
1015            public Constructor<?> getDenseIntMatrixMultiDConstructor() {
1016                    return denseIntMatrixMultiDConstructor;
1017            }
1018    
1019            public Constructor<?> getDenseLongMatrixMultiDConstructor() {
1020                    return denseLongMatrixMultiDConstructor;
1021            }
1022    
1023            public Constructor<?> getDenseShortMatrixMultiDConstructor() {
1024                    return denseShortMatrixMultiDConstructor;
1025            }
1026    
1027            public Constructor<?> getDenseObjectMatrixMultiDConstructor() {
1028                    return denseObjectMatrixMultiDConstructor;
1029            }
1030    
1031            public Constructor<?> getDenseStringMatrixMultiDConstructor() {
1032                    return denseStringMatrixMultiDConstructor;
1033            }
1034    
1035            public Constructor<?> getDenseBigIntegerMatrixMultiDConstructor() {
1036                    return denseBigIntegerMatrixMultiDConstructor;
1037            }
1038    
1039            public Constructor<?> getDenseBigDecimalMatrixMultiDConstructor() {
1040                    return denseBigDecimalMatrixMultiDConstructor;
1041            }
1042    
1043            public Constructor<?> getSparseBooleanMatrix2DConstructor() {
1044                    return sparseBooleanMatrix2DConstructor;
1045            }
1046    
1047            public Constructor<?> getSparseByteMatrix2DConstructor() {
1048                    return sparseByteMatrix2DConstructor;
1049            }
1050    
1051            public Constructor<?> getSparseCharMatrix2DConstructor() {
1052                    return sparseCharMatrix2DConstructor;
1053            }
1054    
1055            public Constructor<?> getSparseDateMatrix2DConstructor() {
1056                    return sparseDateMatrix2DConstructor;
1057            }
1058    
1059            public Constructor<?> getSparseDoubleMatrix2DConstructor() {
1060                    return sparseDoubleMatrix2DConstructor;
1061            }
1062    
1063            public Constructor<?> getSparseFloatMatrix2DConstructor() {
1064                    return sparseFloatMatrix2DConstructor;
1065            }
1066    
1067            public Constructor<?> getSparseIntMatrix2DConstructor() {
1068                    return sparseIntMatrix2DConstructor;
1069            }
1070    
1071            public Constructor<?> getSparseLongMatrix2DConstructor() {
1072                    return sparseLongMatrix2DConstructor;
1073            }
1074    
1075            public Constructor<?> getSparseShortMatrix2DConstructor() {
1076                    return sparseShortMatrix2DConstructor;
1077            }
1078    
1079            public Constructor<?> getSparseObjectMatrix2DConstructor() {
1080                    return sparseObjectMatrix2DConstructor;
1081            }
1082    
1083            public Constructor<?> getSparseStringMatrix2DConstructor() {
1084                    return sparseStringMatrix2DConstructor;
1085            }
1086    
1087            public Constructor<?> getSparseBooleanMatrixMultiDConstructor() {
1088                    return sparseBooleanMatrixMultiDConstructor;
1089            }
1090    
1091            public Constructor<?> getSparseByteMatrixMultiDConstructor() {
1092                    return sparseByteMatrixMultiDConstructor;
1093            }
1094    
1095            public Constructor<?> getSparseCharMatrixMultiDConstructor() {
1096                    return sparseCharMatrixMultiDConstructor;
1097            }
1098    
1099            public Constructor<?> getSparseDateMatrixMultiDConstructor() {
1100                    return sparseDateMatrixMultiDConstructor;
1101            }
1102    
1103            public Constructor<?> getSparseDoubleMatrixMultiDConstructor() {
1104                    return sparseDoubleMatrixMultiDConstructor;
1105            }
1106    
1107            public Constructor<?> getSparseFloatMatrixMultiDConstructor() {
1108                    return sparseFloatMatrixMultiDConstructor;
1109            }
1110    
1111            public Constructor<?> getSparseIntMatrixMultiDConstructor() {
1112                    return sparseIntMatrixMultiDConstructor;
1113            }
1114    
1115            public Constructor<?> getSparseLongMatrixMultiDConstructor() {
1116                    return sparseLongMatrixMultiDConstructor;
1117            }
1118    
1119            public Constructor<?> getSparseShortMatrixMultiDConstructor() {
1120                    return sparseShortMatrixMultiDConstructor;
1121            }
1122    
1123            public Constructor<?> getSparseObjectMatrixMultiDConstructor() {
1124                    return sparseObjectMatrixMultiDConstructor;
1125            }
1126    
1127            public Constructor<?> getSparseStringMatrixMultiDConstructor() {
1128                    return sparseStringMatrixMultiDConstructor;
1129            }
1130    
1131            public Constructor<?> getSparseBigIntegerMatrixMultiDConstructor() {
1132                    return sparseBigIntegerMatrixMultiDConstructor;
1133            }
1134    
1135            public Constructor<?> getSparseBigDecimalMatrixMultiDConstructor() {
1136                    return sparseBigDecimalMatrixMultiDConstructor;
1137            }
1138    
1139            public Constructor<?> getSparseBigIntegerMatrix2DConstructor() {
1140                    return sparseBigIntegerMatrix2DConstructor;
1141            }
1142    
1143            public Constructor<?> getSparseBigDecimalMatrix2DConstructor() {
1144                    return sparseBigDecimalMatrix2DConstructor;
1145            }
1146    
1147            public Constructor<?> getDenseBigIntegerMatrix2DConstructor() {
1148                    return denseBigIntegerMatrix2DConstructor;
1149            }
1150    
1151            public Constructor<?> getDenseBigDecimalMatrix2DConstructor() {
1152                    return denseBigDecimalMatrix2DConstructor;
1153            }
1154    
1155    }