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 }