Fixed #100. feat: Added function rowMultiplication for different Number types to Operations.java

Author: reversedpeach

src/com/jwetherell/algorithms/data_structures/Matrix.java

@@ -4,6 +4,8 @@
 import java.math.BigInteger;
 import java.util.Comparator;
 
+import com.jwetherell.algorithms.mathematics.Operations;
+
 /**
  * Matrx. This Matrix implementation is designed to be more efficient
  * in cache. A matrix is a rectangular array of numbers, symbols, or expressions.
@@ -243,69 +245,7 @@ public Matrix<T> multiply(Matrix<T> input) {
                 T[] row = getRow(r);
                 T[] column = input.getColumn(c);
                 T test = row[0];
-                /* TODO: This is ugly and how to handle number overflow? */
-                if (test instanceof BigDecimal) {
-                    BigDecimal result = BigDecimal.ZERO;
-                    for (int i = 0; i < cols; i++) {
-                        T m1 = row[i];
-                        T m2 = column[i];
-
-                        BigDecimal result2 = ((BigDecimal)m1).multiply(((BigDecimal)m2));
-                        result = result.add(result2);
-                    }
-                    output.set(r, c, (T)result);
-                } else if (test instanceof BigInteger) {
-                    BigInteger result = BigInteger.ZERO;
-                    for (int i = 0; i < cols; i++) {
-                        T m1 = row[i];
-                        T m2 = column[i];
-
-                        BigInteger result2 = ((BigInteger)m1).multiply(((BigInteger)m2));
-                        result = result.add(result2);
-                    }
-                    output.set(r, c, (T)result);
-                } else if (test instanceof Long) {
-                    Long result = 0l;
-                    for (int i = 0; i < cols; i++) {
-                        T m1 = row[i];
-                        T m2 = column[i];
-
-                        Long result2 = m1.longValue() * m2.longValue();
-                        result = result+result2;
-                    }
-                    output.set(r, c, (T)result);
-                } else if (test instanceof Double) {
-                    Double result = 0d;
-                    for (int i = 0; i < cols; i++) {
-                        T m1 = row[i];
-                        T m2 = column[i];
-
-                        Double result2 = m1.doubleValue() * m2.doubleValue();
-                        result = result+result2;
-                    }
-                    output.set(r, c, (T)result);
-                } else if (test instanceof Float) {
-                    Float result = 0f;
-                    for (int i = 0; i < cols; i++) {
-                        T m1 = row[i];
-                        T m2 = column[i];
-
-                        Float result2 = m1.floatValue() * m2.floatValue();
-                        result = result+result2;
-                    }
-                    output.set(r, c, (T)result);
-                } else {
-                    // Integer
-                    Integer result = 0;
-                    for (int i = 0; i < cols; i++) {
-                        T m1 = row[i];
-                        T m2 = column[i];
-
-                        Integer result2 = m1.intValue() * m2.intValue();
-                        result = result+result2;
-                    }
-                    output.set(r, c, (T)result);
-                }
+                output.set(r, c, (T) Operations.rowMultiplication(test, row, column, cols));
             }
         }
         return output;
@@ -318,6 +258,7 @@ public void copy(Matrix<T> m) {
             }
         }
     }
+    
 
     /**
      * {@inheritDoc}

src/com/jwetherell/algorithms/mathematics/Operations.java

@@ -1,5 +1,68 @@
 package com.jwetherell.algorithms.mathematics;
 
-public class Operations{
+import java.math.BigDecimal;
+import java.math.BigInteger;
 
+public class Operations {
+    
+    /* TODO: How to handle number overflow? */
+    public static Number rowMultiplication(Number test, Number[] row, Number[] column, int cols){
+        if (test instanceof BigDecimal) {
+            BigDecimal result = BigDecimal.ZERO;
+            for (int i = 0; i < cols; i++) {
+                Number m1 = row[i];
+                Number m2 = column[i];
+                BigDecimal result2 = ((BigDecimal)m1).multiply(((BigDecimal)m2));
+                result = result.add(result2);
+            }
+            return result;
+        } else if (test instanceof BigInteger) {
+            BigInteger result = BigInteger.ZERO;
+            for (int i = 0; i < cols; i++) {
+                Number m1 = row[i];
+                Number m2 = column[i];
+                BigInteger result2 = ((BigInteger)m1).multiply(((BigInteger)m2));
+                result = result.add(result2);
+            }
+            return result;
+        } else if (test instanceof Long) {
+            Long result = 0l;
+            for (int i = 0; i < cols; i++) {
+                Number m1 = row[i];
+                Number m2 = column[i];
+                Long result2 = m1.longValue() * m2.longValue();
+                result = result+result2;
+            }
+            return result;
+        } else if (test instanceof Double) {
+            Double result = 0d;
+            for (int i = 0; i < cols; i++) {
+                Number m1 = row[i];
+                Number m2 = column[i];
+                Double result2 = m1.doubleValue() * m2.doubleValue();
+                result = result+result2;
+            }
+            return result;
+        } else if (test instanceof Float) {
+            Float result = 0f;
+            for (int i = 0; i < cols; i++) {
+                Number m1 = row[i];
+                Number m2 = column[i];
+                Float result2 = m1.floatValue() * m2.floatValue();
+                result = result+result2;
+            }
+            return result;
+        } else {
+            // Integer
+            Integer result = 0;
+            for (int i = 0; i < cols; i++) {
+                Number m1 = row[i];
+                Number m2 = column[i];
+                Integer result2 = m1.intValue() * m2.intValue();
+                result = result+result2;
+            }
+            return result;
+        }
+    }
+    
 }