[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