[Mulgara-svn] r819 - branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic

pag at mulgara.org pag at mulgara.org
Wed Apr 23 06:36:35 UTC 2008


Author: pag
Date: 2008-04-22 23:36:34 -0700 (Tue, 22 Apr 2008)
New Revision: 819

Modified:
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperation.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperationUnitTest.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperation.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperationUnitTest.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperation.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperationUnitTest.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperation.java
   branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperationUnitTest.java
Log:
Created multi-operand factory methods for each arithmetic filter operation

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperation.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperation.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperation.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,6 +11,8 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.List;
+
 import org.mulgara.query.filter.value.NumericExpression;
 
 
@@ -40,4 +42,29 @@
     return ops.sum(left, right);
   }
 
+  /**
+   * A constructor to handle adding lists of addends.
+   * @param operands The list of addends to sum.
+   * @return A new AddOperation which is adding all the addends.
+   */
+  public static AddOperation newAddOperation(List<NumericExpression> operands) {
+    if (operands.size() < 2) throw new IllegalArgumentException("Require at least 2 addends for addition. Got " + operands.size());
+    return (AddOperation)createNestedAdd(operands);
+  }
+
+  /**
+   * A recursive method to build a NumericExpression that represents the addition of all addends in the list.
+   * @param operands The list of addends to sum.
+   * @return A NumericExpression which represents the addition of everything in the ops list.
+   */
+  private static NumericExpression createNestedAdd(List<NumericExpression> ops) {
+    int listSize = ops.size();
+    // terminate on singleton lists
+    if (listSize == 1) return ops.get(0);
+    // short circuit for 2 element lists - optimization
+    if (listSize == 2) return new AddOperation(ops.get(0), ops.get(1));
+    // general case
+    return new AddOperation(createNestedAdd(ops.subList(0, listSize / 2)), createNestedAdd(ops.subList(listSize / 2, listSize)));
+  }
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperationUnitTest.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperationUnitTest.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/AddOperationUnitTest.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,10 +11,15 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.jrdf.graph.Literal;
 import org.mulgara.query.QueryException;
 
 import org.mulgara.query.filter.value.NumericExpression;
+import org.mulgara.query.filter.value.NumericLiteral;
+import org.mulgara.query.filter.value.SimpleLiteral;
 import org.mulgara.query.filter.value.ValueLiteral;
 
 import junit.framework.Test;
@@ -47,6 +52,7 @@
     TestSuite suite = new TestSuite();
     suite.addTest(new AddOperationUnitTest("testLiteral"));
     suite.addTest(new AddOperationUnitTest("testVar"));
+    suite.addTest(new AddOperationUnitTest("testMultiOp"));
     return suite;
   }
 
@@ -98,5 +104,37 @@
     throw new IllegalArgumentException("Unable to process argument of types: " + t1 + ", " + t2);
   }
 
+  public void testMultiOp() throws Exception {
+    List<NumericExpression> ops = new ArrayList<NumericExpression>();
+    int sum = 0;
+    for (int i = 1; i <= 10; i++) {
+      sum += i;
+      ops.add(new NumericLiteral(i));
+    }
+    AddOperation op = AddOperation.newAddOperation(ops);
+    NumericLiteral literalResult = new NumericLiteral(sum);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());
 
+    ops.clear();
+    ops.add(new NumericLiteral(1));
+    ops.add(new NumericLiteral((float)2.0));
+    ops.add(new NumericLiteral(3L));
+    ops.add(new NumericLiteral(4.0));
+    op = AddOperation.newAddOperation(ops);
+    literalResult = new NumericLiteral(1 + ((float)2.0) + 3L + 4.0);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());    
+  }
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperation.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperation.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperation.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,6 +11,8 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.List;
+
 import org.mulgara.query.filter.value.NumericExpression;
 
 
@@ -40,4 +42,30 @@
     return ops.divide(left, right);
   }
 
+  /**
+   * A constructor to handle dividnd lists of values.
+   * @param operands The list of numbers to divide.
+   * @return A new DivideOperation which is dividing numbers in order.
+   */
+  public static DivideOperation newDivideOperation(List<NumericExpression> operands) {
+    if (operands.size() < 2) throw new IllegalArgumentException("Require at least 2 addends for subtraction. Got " + operands.size());
+    return (DivideOperation)createNestedDivision(operands);
+  }
+
+  /**
+   * A recursive method to build a NumericExpression that represents the division of all values in the list.
+   * This constructs a linked list of divisions.
+   * @param operands The list of values to divide.
+   * @return A NumericExpression which represents the ordered division of everything in the ops list.
+   */
+  private static NumericExpression createNestedDivision(List<NumericExpression> ops) {
+    int listSize = ops.size();
+    // error on singleton lists
+    if (listSize == 1) throw new IllegalStateException("Should not be creating divisions with single elements");
+    // terminate on 2 element lists
+    if (listSize == 2) return new DivideOperation(ops.get(0), ops.get(1));
+    // general case
+    return new DivideOperation(createNestedDivision(ops.subList(0, listSize - 1)), ops.get(listSize - 1));
+  }
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperationUnitTest.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperationUnitTest.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/DivideOperationUnitTest.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,10 +11,15 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.jrdf.graph.Literal;
 import org.mulgara.query.QueryException;
 
 import org.mulgara.query.filter.value.NumericExpression;
+import org.mulgara.query.filter.value.NumericLiteral;
+import org.mulgara.query.filter.value.SimpleLiteral;
 import org.mulgara.query.filter.value.ValueLiteral;
 
 import junit.framework.Test;
@@ -47,6 +52,7 @@
     TestSuite suite = new TestSuite();
     suite.addTest(new DivideOperationUnitTest("testLiteral"));
     suite.addTest(new DivideOperationUnitTest("testVar"));
+    suite.addTest(new DivideOperationUnitTest("testMultiOp"));
     return suite;
   }
 
@@ -98,5 +104,35 @@
     throw new IllegalArgumentException("Unable to process argument of types: " + t1 + ", " + t2);
   }
 
+  public void testMultiOp() throws Exception {
+    List<NumericExpression> ops = new ArrayList<NumericExpression>();
+    ops.add(new NumericLiteral(100));
+    ops.add(new NumericLiteral(4));
+    ops.add(new NumericLiteral(5));
+    DivideOperation op = DivideOperation.newDivideOperation(ops);
+    NumericLiteral literalResult = new NumericLiteral(5);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());
 
+    ops.clear();
+    ops.add(new NumericLiteral(100));
+    ops.add(new NumericLiteral((float)2.0));
+    ops.add(new NumericLiteral(5L));
+    ops.add(new NumericLiteral(4.0));
+    op = DivideOperation.newDivideOperation(ops);
+    literalResult = new NumericLiteral(100 / ((float)2.0) / 5L / 4.0);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());
+  }
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperation.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperation.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperation.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,6 +11,8 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.List;
+
 import org.mulgara.query.filter.value.NumericExpression;
 
 
@@ -40,4 +42,29 @@
     return ops.subtract(left, right);
   }
 
+  /**
+   * A constructor to handle subtracting lists of values.
+   * @param operands The list of numbers to subtract.
+   * @return A new MinusOperation which is subtracting numbers in order.
+   */
+  public static MinusOperation newMinusOperation(List<NumericExpression> operands) {
+    if (operands.size() < 2) throw new IllegalArgumentException("Require at least 2 addends for subtraction. Got " + operands.size());
+    return (MinusOperation)createNestedSubtraction(operands);
+  }
+
+  /**
+   * A recursive method to build a NumericExpression that represents the subtraction of all values in the list.
+   * @param operands The list of values to subtract.
+   * @return A NumericExpression which represents the ordered subtraction of everything in the ops list.
+   */
+  private static NumericExpression createNestedSubtraction(List<NumericExpression> ops) {
+    int listSize = ops.size();
+    // error on singleton lists
+    if (listSize == 1) throw new IllegalStateException("Should not be creating subtractions with single elements");
+    // terminate on 2 element lists
+    if (listSize == 2) return new MinusOperation(ops.get(0), ops.get(1));
+    // general case
+    return new MinusOperation(createNestedSubtraction(ops.subList(0, listSize - 1)), ops.get(listSize - 1));
+  }
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperationUnitTest.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperationUnitTest.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MinusOperationUnitTest.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,10 +11,15 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.jrdf.graph.Literal;
 import org.mulgara.query.QueryException;
 
 import org.mulgara.query.filter.value.NumericExpression;
+import org.mulgara.query.filter.value.NumericLiteral;
+import org.mulgara.query.filter.value.SimpleLiteral;
 import org.mulgara.query.filter.value.ValueLiteral;
 
 import junit.framework.Test;
@@ -47,6 +52,7 @@
     TestSuite suite = new TestSuite();
     suite.addTest(new MinusOperationUnitTest("testLiteral"));
     suite.addTest(new MinusOperationUnitTest("testVar"));
+    suite.addTest(new MinusOperationUnitTest("testMultiOp"));
     return suite;
   }
 
@@ -98,5 +104,36 @@
     throw new IllegalArgumentException("Unable to process argument of types: " + t1 + ", " + t2);
   }
 
+  public void testMultiOp() throws Exception {
+    List<NumericExpression> ops = new ArrayList<NumericExpression>();
+    ops.add(new NumericLiteral(100));
+    ops.add(new NumericLiteral(60));
+    ops.add(new NumericLiteral(5));
+    MinusOperation op = MinusOperation.newMinusOperation(ops);
+    NumericLiteral literalResult = new NumericLiteral(35);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());
 
+    ops.clear();
+    ops.add(new NumericLiteral(100));
+    ops.add(new NumericLiteral((float)2.0));
+    ops.add(new NumericLiteral(5L));
+    ops.add(new NumericLiteral(4.0));
+    op = MinusOperation.newMinusOperation(ops);
+    literalResult = new NumericLiteral(100 - ((float)2.0) - 5L - 4.0);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());
+  }
+
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperation.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperation.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperation.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,6 +11,8 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.List;
+
 import org.mulgara.query.filter.value.NumericExpression;
 
 
@@ -40,4 +42,29 @@
     return ops.product(left, right);
   }
 
+  /**
+   * A constructor to handle adding lists of multipliers.
+   * @param operands The list of multipliers to multiply.
+   * @return A new MultiplyOperation which is multiplying all the elements.
+   */
+  public static MultiplyOperation newMultiplyOperation(List<NumericExpression> operands) {
+    if (operands.size() < 2) throw new IllegalArgumentException("Require at least 2 addends for multiplication. Got " + operands.size());
+    return (MultiplyOperation)createNestedMultiply(operands);
+  }
+
+  /**
+   * A recursive method to build a NumericExpression that represents the product of all multipliers in the list.
+   * @param operands The list of multipliers to multiply.
+   * @return A NumericExpression which represents the product of everything in the ops list.
+   */
+  private static NumericExpression createNestedMultiply(List<NumericExpression> ops) {
+    int listSize = ops.size();
+    // terminate on singleton lists
+    if (listSize == 1) return ops.get(0);
+    // short circuit for 2 element lists - optimization
+    if (listSize == 2) return new MultiplyOperation(ops.get(0), ops.get(1));
+    // general case
+    return new MultiplyOperation(createNestedMultiply(ops.subList(0, listSize / 2)), createNestedMultiply(ops.subList(listSize / 2, listSize)));
+  }
+
 }

Modified: branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperationUnitTest.java
===================================================================
--- branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperationUnitTest.java	2008-04-23 03:46:28 UTC (rev 818)
+++ branches/mgr-61-sparql/src/jar/query/java/org/mulgara/query/filter/arithmetic/MultiplyOperationUnitTest.java	2008-04-23 06:36:34 UTC (rev 819)
@@ -11,10 +11,15 @@
  */
 package org.mulgara.query.filter.arithmetic;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.jrdf.graph.Literal;
 import org.mulgara.query.QueryException;
 
 import org.mulgara.query.filter.value.NumericExpression;
+import org.mulgara.query.filter.value.NumericLiteral;
+import org.mulgara.query.filter.value.SimpleLiteral;
 import org.mulgara.query.filter.value.ValueLiteral;
 
 import junit.framework.Test;
@@ -47,6 +52,7 @@
     TestSuite suite = new TestSuite();
     suite.addTest(new MultiplyOperationUnitTest("testLiteral"));
     suite.addTest(new MultiplyOperationUnitTest("testVar"));
+    suite.addTest(new MultiplyOperationUnitTest("testMultiOp"));
     return suite;
   }
 
@@ -98,5 +104,37 @@
     throw new IllegalArgumentException("Unable to process argument of types: " + t1 + ", " + t2);
   }
 
+  public void testMultiOp() throws Exception {
+    List<NumericExpression> ops = new ArrayList<NumericExpression>();
+    int product = 1;
+    for (int i = 2; i <= 5; i++) {
+      product *= i;
+      ops.add(new NumericLiteral(i));
+    }
+    MultiplyOperation op = MultiplyOperation.newMultiplyOperation(ops);
+    NumericLiteral literalResult = new NumericLiteral(product);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());
 
+    ops.clear();
+    ops.add(new NumericLiteral(1));
+    ops.add(new NumericLiteral((float)2.0));
+    ops.add(new NumericLiteral(3L));
+    ops.add(new NumericLiteral(4.0));
+    op = MultiplyOperation.newMultiplyOperation(ops);
+    literalResult = new NumericLiteral(1 * ((float)2.0) * 3L * 4.0);
+    assertTrue(op.equals(literalResult));
+    assertFalse(op.isBlank());
+    assertFalse(op.isIRI());
+    assertTrue(op.isLiteral());
+    assertFalse(op.isURI());
+    assertTrue(literalResult.getType().equals(op.getType()));
+    assertEquals(SimpleLiteral.EMPTY, op.getLang());    
+  }
+
 }




More information about the Mulgara-svn mailing list