/*
* 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);
}
}