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.calculation; 025 026 import java.math.BigDecimal; 027 028 import org.ujmp.core.Matrix; 029 import org.ujmp.core.doublematrix.DenseDoubleMatrix2D; 030 import org.ujmp.core.interfaces.HasColumnMajorDoubleArray1D; 031 import org.ujmp.core.interfaces.HasRowMajorDoubleArray2D; 032 import org.ujmp.core.matrix.DenseMatrix; 033 import org.ujmp.core.matrix.DenseMatrix2D; 034 import org.ujmp.core.matrix.SparseMatrix; 035 import org.ujmp.core.util.MathUtil; 036 import org.ujmp.core.util.UJMPSettings; 037 import org.ujmp.core.util.VerifyUtil; 038 import org.ujmp.core.util.concurrent.PForEquidistant; 039 040 public class DivideMatrix { 041 042 public static final DivideMatrixCalculation<Matrix, Matrix, Matrix> MATRIX = new DivideMatrixMatrix(); 043 044 public static final DivideMatrixCalculation<DenseMatrix, DenseMatrix, DenseMatrix> DENSEMATRIX = new DivideMatrixDenseMatrix(); 045 046 public static final DivideMatrixCalculation<DenseMatrix2D, DenseMatrix2D, DenseMatrix2D> DENSEMATRIX2D = new DivideMatrixDenseMatrix2D(); 047 048 public static final DivideMatrixCalculation<DenseDoubleMatrix2D, DenseDoubleMatrix2D, DenseDoubleMatrix2D> DENSEDOUBLEMATRIX2D = new DivideMatrixDenseDoubleMatrix2D(); 049 050 public static final DivideMatrixCalculation<SparseMatrix, SparseMatrix, SparseMatrix> SPARSEMATRIX = new DivideMatrixSparseMatrix(); 051 } 052 053 class DivideMatrixDenseMatrix implements 054 DivideMatrixCalculation<DenseMatrix, DenseMatrix, DenseMatrix> { 055 public final void calc(final DenseMatrix source1, final DenseMatrix source2, 056 final DenseMatrix target) { 057 if (source1 instanceof DenseMatrix2D && source2 instanceof DenseMatrix2D 058 && target instanceof DenseMatrix2D) { 059 DivideMatrix.DENSEMATRIX2D.calc((DenseMatrix2D) source1, (DenseMatrix2D) source2, 060 (DenseMatrix2D) target); 061 } else { 062 VerifyUtil.assertSameSize(source1, source2, target); 063 for (long[] c : source1.allCoordinates()) { 064 BigDecimal v1 = source1.getAsBigDecimal(c); 065 BigDecimal v2 = source2.getAsBigDecimal(c); 066 BigDecimal result = MathUtil.divide(v1, v2); 067 target.setAsBigDecimal(result, c); 068 } 069 } 070 } 071 072 } 073 074 class DivideMatrixDenseMatrix2D implements 075 DivideMatrixCalculation<DenseMatrix2D, DenseMatrix2D, DenseMatrix2D> { 076 077 public final void calc(final DenseMatrix2D source1, final DenseMatrix2D source2, 078 final DenseMatrix2D target) { 079 if (source1 instanceof DenseDoubleMatrix2D && source2 instanceof DenseDoubleMatrix2D 080 && target instanceof DenseDoubleMatrix2D) { 081 DivideMatrix.DENSEDOUBLEMATRIX2D.calc((DenseDoubleMatrix2D) source1, 082 (DenseDoubleMatrix2D) source2, (DenseDoubleMatrix2D) target); 083 } else { 084 VerifyUtil.assertSameSize(source1, source2, target); 085 for (int r = (int) source1.getRowCount(); --r != -1;) { 086 for (int c = (int) source1.getColumnCount(); --c != -1;) { 087 BigDecimal v1 = source1.getAsBigDecimal(r, c); 088 BigDecimal v2 = source2.getAsBigDecimal(r, c); 089 BigDecimal result = MathUtil.divide(v1, v2); 090 target.setAsBigDecimal(result, r, c); 091 } 092 } 093 } 094 } 095 } 096 097 class DivideMatrixDenseDoubleMatrix2D implements 098 DivideMatrixCalculation<DenseDoubleMatrix2D, DenseDoubleMatrix2D, DenseDoubleMatrix2D> { 099 100 public final void calc(final DenseDoubleMatrix2D source1, final DenseDoubleMatrix2D source2, 101 final DenseDoubleMatrix2D target) { 102 if (source1 instanceof HasColumnMajorDoubleArray1D 103 && source2 instanceof HasColumnMajorDoubleArray1D 104 && target instanceof HasColumnMajorDoubleArray1D) { 105 calc(((HasColumnMajorDoubleArray1D) source1).getColumnMajorDoubleArray1D(), 106 ((HasColumnMajorDoubleArray1D) source2).getColumnMajorDoubleArray1D(), 107 ((HasColumnMajorDoubleArray1D) target).getColumnMajorDoubleArray1D()); 108 } else if (source1 instanceof HasRowMajorDoubleArray2D 109 && source2 instanceof HasRowMajorDoubleArray2D 110 && target instanceof HasRowMajorDoubleArray2D) { 111 calc(((HasRowMajorDoubleArray2D) source1).getRowMajorDoubleArray2D(), 112 ((HasRowMajorDoubleArray2D) source2).getRowMajorDoubleArray2D(), 113 ((HasRowMajorDoubleArray2D) target).getRowMajorDoubleArray2D()); 114 } else { 115 VerifyUtil.assertSameSize(source1, source2, target); 116 for (int r = (int) source1.getRowCount(); --r != -1;) { 117 for (int c = (int) source1.getColumnCount(); --c != -1;) { 118 target.setDouble(source1.getDouble(r, c) / source2.getDouble(r, c), r, c); 119 } 120 } 121 } 122 } 123 124 private final void calc(final double[][] source1, final double[][] source2, 125 final double[][] target) { 126 VerifyUtil.assertSameSize(source1, source2, target); 127 if (UJMPSettings.getNumberOfThreads() > 1 && source1.length >= 100 128 && source1[0].length >= 100) { 129 new PForEquidistant(0, source1.length - 1) { 130 public void step(int i) { 131 double[] v1 = source1[i]; 132 double[] v2 = source2[i]; 133 double[] t = target[i]; 134 for (int c = source1[0].length; --c != -1;) { 135 t[c] = v1[c] / v2[c]; 136 } 137 } 138 }; 139 } else { 140 double[] v1 = null; 141 double[] v2 = null; 142 double[] t = null; 143 for (int r = source1.length; --r != -1;) { 144 v1 = source1[r]; 145 v2 = source2[r]; 146 t = target[r]; 147 for (int c = source1[0].length; --c != -1;) { 148 t[c] = v1[c] / v2[c]; 149 } 150 } 151 } 152 } 153 154 private final void calc(final double[] source1, final double[] source2, final double[] target) { 155 VerifyUtil.assertSameSize(source1, source2, target); 156 final int length = source1.length; 157 for (int i = 0; i < length; i++) { 158 target[i] = source1[i] / source2[i]; 159 } 160 } 161 162 } 163 164 class DivideMatrixSparseMatrix implements 165 DivideMatrixCalculation<SparseMatrix, SparseMatrix, SparseMatrix> { 166 167 public final void calc(final SparseMatrix source1, final SparseMatrix source2, 168 final SparseMatrix target) { 169 VerifyUtil.assertSameSize(source1, source2, target); 170 // have to iterate over all values in source2 to perform division by 171 // zero if necessary 172 for (long[] c : source2.allCoordinates()) { 173 BigDecimal v1 = source1.getAsBigDecimal(c); 174 BigDecimal v2 = source2.getAsBigDecimal(c); 175 BigDecimal result = MathUtil.divide(v1, v2); 176 target.setAsBigDecimal(result, c); 177 } 178 } 179 } 180 181 class DivideMatrixMatrix implements DivideMatrixCalculation<Matrix, Matrix, Matrix> { 182 183 public final void calc(final Matrix source1, final Matrix source2, final Matrix target) { 184 if (source1 instanceof DenseMatrix && source2 instanceof DenseMatrix 185 && target instanceof DenseMatrix) { 186 DivideMatrix.DENSEMATRIX.calc((DenseMatrix) source1, (DenseMatrix) source2, 187 (DenseMatrix) target); 188 } else if (source1 instanceof SparseMatrix && source2 instanceof SparseMatrix 189 && target instanceof SparseMatrix) { 190 DivideMatrix.SPARSEMATRIX.calc((SparseMatrix) source1, (SparseMatrix) source2, 191 (SparseMatrix) target); 192 } else { 193 VerifyUtil.assertSameSize(source1, source2, target); 194 for (long[] c : source1.allCoordinates()) { 195 BigDecimal v1 = source1.getAsBigDecimal(c); 196 BigDecimal v2 = source2.getAsBigDecimal(c); 197 BigDecimal result = MathUtil.divide(v1, v2); 198 target.setAsBigDecimal(result, c); 199 } 200 } 201 } 202 }