You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@pig.apache.org by ol...@apache.org on 2008/10/30 22:27:17 UTC
svn commit: r709249 [4/4] - in /hadoop/pig/branches/types/contrib: ./
piggybank/ piggybank/java/ piggybank/java/lib/ piggybank/java/src/
piggybank/java/src/main/ piggybank/java/src/main/java/
piggybank/java/src/main/java/org/ piggybank/java/src/main/ja...
Added: hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestMathUDF.java
URL: http://svn.apache.org/viewvc/hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestMathUDF.java?rev=709249&view=auto
==============================================================================
--- hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestMathUDF.java (added)
+++ hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestMathUDF.java Thu Oct 30 14:27:14 2008
@@ -0,0 +1,375 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.pig.piggybank.test.evaluation;
+
+import org.apache.pig.piggybank.evaluation.math.*;
+
+import org.apache.pig.EvalFunc;
+import org.apache.pig.data.Tuple;
+import org.apache.pig.data.DefaultTupleFactory;
+
+import junit.framework.TestCase;
+
+public class TestMathUDF extends TestCase{
+ public double delta = 0.001;
+
+ public void testABS() throws Exception {
+ ABS abs = new ABS();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, -1.0);}catch(Exception e){}
+ Double actual = abs.exec(tup);
+ double expected = 1.0;
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testACOS() throws Exception {
+ ACOS acos = new ACOS();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = acos.exec(tup);
+ double expected = Math.acos(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testASIN() throws Exception {
+ ASIN asin = new ASIN();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = asin.exec(tup);
+ double expected = Math.asin(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testATAN() throws Exception {
+ ATAN atan = new ATAN();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = atan.exec(tup);
+ double expected = Math.atan(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testATAN2() throws Exception {
+ ATAN2 atan2 = new ATAN2();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, 0.5);
+ tup.set(1,0.6);
+ }catch(Exception e){}
+
+ Double actual = atan2.exec(tup);
+ double expected = Math.atan2(0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testCBRT() throws Exception{
+ CBRT cbrt = new CBRT();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = cbrt.exec(tup);
+ double expected = Math.cbrt(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testCEIL() throws Exception{
+ CEIL ceil = new CEIL();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = ceil.exec(tup);
+ double expected = Math.ceil(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testcopySign() throws Exception {
+ copySign cpSign = new copySign();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, -0.5);
+ tup.set(1,0.6);
+ }catch(Exception e){}
+ Double actual = cpSign.exec(tup);
+ double expected = Math.copySign(-0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testCOS() throws Exception{
+ COS cos = new COS();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = cos.exec(tup);
+ double expected = Math.cos(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testCOSH() throws Exception{
+ COSH cosh = new COSH();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = cosh.exec(tup);
+ double expected = Math.cosh(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testEXP() throws Exception{
+ EXP exp = new EXP();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = exp.exec(tup);
+ double expected = Math.exp(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testEXPM1() throws Exception{
+ EXPM1 expm1 = new EXPM1();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = expm1.exec(tup);
+ double expected = Math.expm1(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testFLOOR() throws Exception{
+ FLOOR floor = new FLOOR();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = floor.exec(tup);
+ double expected = Math.floor(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testgetExponent() throws Exception{
+ getExponent getExp = new getExponent();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Integer actual = getExp.exec(tup);
+ int expected = Math.getExponent(-0.5);
+ assertEquals((int)actual, expected);
+ }
+
+ public void testHYPOT() throws Exception {
+ HYPOT hypot = new HYPOT();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, -0.5);
+ tup.set(1,0.6);
+ }catch (Exception e){}
+ Double actual = hypot.exec(tup);
+ double expected = Math.hypot(-0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testIEEEremainder() throws Exception {
+ IEEEremainder rem = new IEEEremainder();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, -0.5);
+ tup.set(1,0.6);
+ }catch (Exception e){}
+ Double actual = rem.exec(tup);
+ double expected = Math.IEEEremainder(-0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testLOG() throws Exception{
+ LOG log= new LOG();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = log.exec(tup);
+ double expected = Math.log(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testLOG10() throws Exception{
+ LOG10 log10 = new LOG10();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = log10.exec(tup);
+ double expected = Math.log10(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testLOG1P() throws Exception{
+ LOG1P log1p = new LOG1P();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = log1p.exec(tup);
+ double expected = Math.log1p(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testMAX() throws Exception {
+ MAX max = new MAX();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, -0.5);
+ tup.set(1,0.6);
+ }catch (Exception e){}
+ Double actual = max.exec(tup);
+ double expected = Math.max(-0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testMIN() throws Exception {
+ MIN min = new MIN();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, -0.5);
+ tup.set(1,0.6);
+ }catch (Exception e){}
+ Double actual = min.exec(tup);
+ double expected = Math.min(-0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testnextAfter() throws Exception {
+ nextAfter next = new nextAfter();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, -0.5);
+ tup.set(1,0.6);
+ }catch (Exception e){}
+ Double actual = next.exec(tup);
+ double expected = Math.nextAfter(-0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testPOW() throws Exception {
+ POW pow = new POW();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, 0.5);
+ tup.set(1,0.6);
+ }catch (Exception e){}
+ Double actual = pow.exec(tup);
+ double expected = Math.pow(0.5,0.6);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testRINT() throws Exception{
+ RINT rint = new RINT();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = rint.exec(tup);
+ double expected = Math.rint(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testROUND() throws Exception{
+ ROUND round = new ROUND();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Long actual = round.exec(tup);
+ long expected = Math.round(0.5);
+ assertEquals((long)actual, expected);
+ }
+
+ public void testSCALB() throws Exception {
+ SCALB scalb = new SCALB();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(2);
+ try{
+ tup.set(0, 1);
+ tup.set(1, 2);
+ }catch (Exception e){}
+ Double actual = scalb.exec(tup);
+ double expected = Math.scalb(1,2);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testSIGNUM() throws Exception{
+ SIGNUM signum = new SIGNUM();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = signum.exec(tup);
+ double expected = Math.signum(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testSIN() throws Exception{
+ SIN sin = new SIN();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = sin.exec(tup);
+ double expected = Math.sin(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testSINH() throws Exception{
+ SINH sinh = new SINH();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = sinh.exec(tup);
+ double expected = Math.sinh(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testSQRT() throws Exception{
+ SQRT sqrt = new SQRT();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = sqrt.exec(tup);
+ double expected = Math.sqrt(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testTAN() throws Exception{
+ TAN tan = new TAN();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = tan.exec(tup);
+ double expected = Math.tan(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testTANH() throws Exception{
+ TANH tanh = new TANH();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = tanh.exec(tup);
+ double expected = Math.tanh(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testtoDegree() throws Exception{
+ toDegrees degree = new toDegrees();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = degree.exec(tup);
+ double expected = Math.toDegrees(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testtoRadians() throws Exception{
+ toRadians radian = new toRadians();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = radian.exec(tup);
+ double expected = Math.toRadians(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+ public void testULP() throws Exception{
+ ULP ulp = new ULP();
+ Tuple tup = DefaultTupleFactory.getInstance().newTuple(1);
+ try{tup.set(0, 0.5);}catch(Exception e){}
+ Double actual = ulp.exec(tup);
+ double expected = Math.ulp(0.5);
+ assertEquals(actual, expected, delta);
+ }
+
+}
Added: hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestStat.java
URL: http://svn.apache.org/viewvc/hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestStat.java?rev=709249&view=auto
==============================================================================
--- hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestStat.java (added)
+++ hadoop/pig/branches/types/contrib/piggybank/java/src/test/java/org/apache/pig/piggybank/test/evaluation/TestStat.java Thu Oct 30 14:27:14 2008
@@ -0,0 +1,135 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.pig.piggybank.test.evaluation;
+
+import java.util.Iterator;
+import org.apache.pig.EvalFunc;
+import org.apache.pig.data.DataBag;
+import org.apache.pig.data.DefaultBagFactory;
+import org.apache.pig.data.Tuple;
+import org.apache.pig.data.DefaultTupleFactory;
+import org.apache.pig.piggybank.evaluation.stats.COR;
+import org.apache.pig.piggybank.evaluation.stats.COV;
+
+import junit.framework.TestCase;
+
+public class TestStat extends TestCase{
+
+ public void testCOV() throws Exception{
+ COV cov = new COV("a","b");
+ DataBag dBag = DefaultBagFactory.getInstance().newDefaultBag();
+ Tuple tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 1.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 4.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 8.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 4.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 7.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 8.0);
+ dBag.add(tup1);
+ DataBag dBag1 = DefaultBagFactory.getInstance().newDefaultBag();
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 2.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 2.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 3.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 3.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 2.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 4.0);
+ dBag1.add(tup1);
+ Tuple input = DefaultTupleFactory.getInstance().newTuple(2);
+ input.set(0, dBag);
+ input.set(1, dBag1);
+ DataBag output = cov.exec(input);
+ Iterator<Tuple> it = output.iterator();
+ Tuple ans = (Tuple)it.next();
+ assertEquals((String)ans.get(0),"a");
+ assertEquals((String)ans.get(1),"b");
+ assertEquals(1.11111, (Double)ans.get(2),0.0005);
+ }
+
+ public void testCOR() throws Exception{
+ COR cor = new COR("a","b");
+ DataBag dBag = DefaultBagFactory.getInstance().newDefaultBag();
+ Tuple tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 1.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 4.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 8.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 4.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 7.0);
+ dBag.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 8.0);
+ dBag.add(tup1);
+ DataBag dBag1 = DefaultBagFactory.getInstance().newDefaultBag();
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 2.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 2.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 3.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 3.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 2.0);
+ dBag1.add(tup1);
+ tup1 = DefaultTupleFactory.getInstance().newTuple(1);
+ tup1.set(0, 4.0);
+ dBag1.add(tup1);
+ Tuple input = DefaultTupleFactory.getInstance().newTuple(2);
+ input.set(0, dBag);
+ input.set(1, dBag1);
+ DataBag output = cor.exec(input);
+ Iterator<Tuple> it = output.iterator();
+ Tuple ans = (Tuple) it.next();
+ assertEquals((String)ans.get(0),"a");
+ assertEquals((String)ans.get(1),"b");
+ assertEquals(0.582222509739582, (Double)ans.get(2) ,0.0005);
+ }
+}