Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed 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 com.facebook.presto.operator.scalar;
 
 
 import static com.facebook.presto.SessionTestUtils.TEST_SESSION;
 
 public class TestMathFunctions
 {
     private static final double[] DOUBLE_VALUES = {123, -123, 123.45, -123.45};
     private static final long[] longLefts = {9, 10, 11, -9, -10, -11};
     private static final long[] longRights = {3, -3};
     private static final double[] doubleLefts = {9, 10, 11, -9, -10, -11, 9.1, 10.1, 11.1, -9.1, -10.1, -11.1};
     private static final double[] doubleRights = {3, -3, 3.1, -3.1};
 
 
     @BeforeClass
     public void setUp()
     {
          = new FunctionAssertions();
     }
 
     @Test
     public void testAbs()
     {
         assertFunction("abs(123)", 123L);
         assertFunction("abs(-123)", 123L);
         assertFunction("abs(123.0)", 123.0);
         assertFunction("abs(-123.0)", 123.0);
         assertFunction("abs(123.45)", 123.45);
         assertFunction("abs(-123.45)", 123.45);
     }
 
     @Test
     public void testAcos()
     {
         for (double doubleValue : ) {
             assertFunction("acos(" + doubleValue + ")", Math.acos(doubleValue));
         }
     }
 
     @Test
     public void testAsin()
     {
         for (double doubleValue : ) {
             assertFunction("asin(" + doubleValue + ")", Math.asin(doubleValue));
         }
     }
 
     @Test
     public void testAtan()
     {
         for (double doubleValue : ) {
             assertFunction("atan(" + doubleValue + ")", Math.atan(doubleValue));
         }
     }
 
     @Test
     public void testAtan2()
     {
         for (double doubleValue : ) {
             assertFunction("atan2(" + doubleValue + ", " + doubleValue + ")", Math.atan2(doubleValuedoubleValue));
         }
     }
 
     @Test
     public void testCbrt()
     {
         for (double doubleValue : ) {
             assertFunction("cbrt(" + doubleValue + ")", Math.cbrt(doubleValue));
         }
     }
 
     @Test
     public void testCeil()
     {
         assertFunction("ceil(123)", 123);
         assertFunction("ceil(-123)", -123);
         assertFunction("ceil(123.0)", 123.0);
         assertFunction("ceil(-123.0)", -123.0);
         assertFunction("ceil(123.45)", 124.0);
         assertFunction("ceil(-123.45)", -123.0);
         assertFunction("ceiling(123)", 123);
         assertFunction("ceiling(-123)", -123);
        assertFunction("ceiling(123.0)", 123.0);
        assertFunction("ceiling(-123.0)", -123.0);
        assertFunction("ceiling(123.45)", 124.0);
        assertFunction("ceiling(-123.45)", -123.0);
    }
    @Test
    public void testCos()
    {
        for (double doubleValue : ) {
            assertFunction("cos(" + doubleValue + ")", Math.cos(doubleValue));
        }
    }
    @Test
    public void testCosh()
    {
        for (double doubleValue : ) {
            assertFunction("cosh(" + doubleValue + ")", Math.cosh(doubleValue));
        }
    }
    @Test
    public void testE()
    {
        assertFunction("e()".);
    }
    @Test
    public void testExp()
    {
        for (double doubleValue : ) {
            assertFunction("exp(" + doubleValue + ")", Math.exp(doubleValue));
        }
    }
    @Test
    public void testFloor()
    {
        assertFunction("floor(123)", 123);
        assertFunction("floor(-123)", -123);
        assertFunction("floor(123.0)", 123.0);
        assertFunction("floor(-123.0)", -123.0);
        assertFunction("floor(123.45)", 123.0);
        assertFunction("floor(-123.45)", -124.0);
    }
    @Test
    public void testLn()
    {
        for (double doubleValue : ) {
            assertFunction("ln(" + doubleValue + ")", Math.log(doubleValue));
        }
    }
    @Test
    public void testLog2()
    {
        for (double doubleValue : ) {
            assertFunction("log2(" + doubleValue + ")", Math.log(doubleValue) / Math.log(2));
        }
    }
    @Test
    public void testLog10()
    {
        for (double doubleValue : ) {
            assertFunction("log10(" + doubleValue + ")", Math.log10(doubleValue));
        }
    }
    @Test
    public void testLog()
    {
        for (double doubleValue : ) {
            for (double base : ) {
                assertFunction("log(" + doubleValue + ", " + base + ")", Math.log(doubleValue) / Math.log(base));
            }
        }
    }
    @Test
    public void testMod()
    {
        for (long left : ) {
            for (long right : ) {
                assertFunction("mod(" + left + ", " + right + ")"left % right);
            }
        }
        for (long left : ) {
            for (double right : ) {
                assertFunction("mod(" + left + ", " + right + ")"left % right);
            }
        }
        for (double left : ) {
            for (long right : ) {
                assertFunction("mod(" + left + ", " + right + ")"left % right);
            }
        }
        for (double left : ) {
            for (double right : ) {
                assertFunction("mod(" + left + ", " + right + ")"left % right);
            }
        }
    }
    @Test
    public void testPi()
    {
        assertFunction("pi()".);
    }
    @Test
    public void testNaN()
    {
        assertFunction("nan()".);
        assertFunction("0.0 / 0.0".);
    }
    @Test
    public void testInfinity()
    {
        assertFunction("infinity()".);
        assertFunction("-rand() / 0.0".);
    }
    @Test
    public void testIsInfinite()
    {
        assertFunction("is_infinite(1.0 / 0.0)"true);
        assertFunction("is_infinite(0.0 / 0.0)"false);
        assertFunction("is_infinite(1.0 / 1.0)"false);
    }
    @Test
    public void testIsFinite()
    {
        assertFunction("is_finite(100000)"true);
        assertFunction("is_finite(rand() / 0.0)"false);
    }
    @Test
    public void testIsNaN()
    {
        assertFunction("is_nan(0.0 / 0.0)"true);
        assertFunction("is_nan(0.0 / 1.0)"false);
        assertFunction("is_nan(infinity() / infinity())"true);
        assertFunction("is_nan(nan())"true);
    }
    @Test
    public void testPow()
    {
        for (long left : ) {
            for (long right : ) {
                assertFunction("pow(" + left + ", " + right + ")", Math.pow(leftright));
            }
        }
        for (long left : ) {
            for (double right : ) {
                assertFunction("pow(" + left + ", " + right + ")", Math.pow(leftright));
            }
        }
        for (double left : ) {
            for (long right : ) {
                assertFunction("pow(" + left + ", " + right + ")", Math.pow(leftright));
            }
        }
        for (double left : ) {
            for (double right : ) {
                assertFunction("pow(" + left + ", " + right + ")", Math.pow(leftright));
            }
        }
    }
    @Test
    public void testRandom()
    {
        // random is non-deterministic
    }
    @Test
    public void testRound()
    {
        assertFunction("round( 3)", 3);
        assertFunction("round(-3)", -3);
        assertFunction("round( 3.0)", 3.0);
        assertFunction("round(-3.0)", -3.0);
        assertFunction("round( 3.499)", 3.0);
        assertFunction("round(-3.499)", -3.0);
        assertFunction("round( 3.5)", 4.0);
        assertFunction("round(-3.5)", -4.0);
        assertFunction("round(-3.5001)", -4.0);
        assertFunction("round(-3.99)", -4.0);
        assertFunction("round( 3, 0)", 3);
        assertFunction("round(-3, 0)", -3);
        assertFunction("round( 3.0, 0)", 3.0);
        assertFunction("round(-3.0, 0)", -3.0);
        assertFunction("round( 3.499, 0)", 3.0);
        assertFunction("round(-3.499, 0)", -3.0);
        assertFunction("round( 3.5, 0)", 4.0);
        assertFunction("round(-3.5, 0)", -4.0);
        assertFunction("round(-3.5001, 0)", -4.0);
        assertFunction("round(-3.99, 0)", -4.0);
        assertFunction("round( 3, 1)", 3);
        assertFunction("round(-3, 1)", -3);
        assertFunction("round( 3.0, 1)", 3.0);
        assertFunction("round(-3.0, 1)", -3.0);
        assertFunction("round( 3.499, 1)", 3.5);
        assertFunction("round(-3.499, 1)", -3.5);
        assertFunction("round( 3.5, 1)", 3.5);
        assertFunction("round(-3.5, 1)", -3.5);
        assertFunction("round(-3.5001, 1)", -3.5);
        assertFunction("round(-3.99, 1)", -4.0);
    }
    @Test
    public void testSin()
    {
        for (double doubleValue : ) {
            assertFunction("sin(" + doubleValue + ")", Math.sin(doubleValue));
        }
    }
    @Test
    public void testSqrt()
    {
        for (double doubleValue : ) {
            assertFunction("sqrt(" + doubleValue + ")", Math.sqrt(doubleValue));
        }
    }
    @Test
    public void testTan()
    {
        for (double doubleValue : ) {
            assertFunction("tan(" + doubleValue + ")", Math.tan(doubleValue));
        }
    }
    @Test
    public void testTanh()
    {
        for (double doubleValue : ) {
            assertFunction("tanh(" + doubleValue + ")", Math.tanh(doubleValue));
        }
    }
    @Test
    public void testGreatest()
            throws Exception
    {
        // bigint
        assertFunction("greatest(1, 2)", 2);
        assertFunction("greatest(-1, -2)", -1);
        assertFunction("greatest(5, 4, 3, 2, 1, 2, 3, 4, 1, 5)", 5);
        assertFunction("greatest(-1)", -1);
        // double
        assertFunction("greatest(1.5, 2.3)", 2.3);
        assertFunction("greatest(-1.5, -2.3)", -1.5);
        assertFunction("greatest(-1.5, -2.3, -5/3)", -1.0);
        assertFunction("greatest(1.5, -1.0 / 0.0, 1.0 / 0.0)".);
        // mixed
        assertFunction("greatest(1, 2.0)", 2.0);
        assertFunction("greatest(1.0, 2)", 2.0);
    }
    @Test
    public void testLeast()
            throws Exception
    {
        // bigint
        assertFunction("least(1, 2)", 1);
        assertFunction("least(-1, -2)", -2);
        assertFunction("least(5, 4, 3, 2, 1, 2, 3, 4, 1, 5)", 1);
        assertFunction("least(-1)", -1);
        // double
        assertFunction("least(1.5, 2.3)", 1.5);
        assertFunction("least(-1.5, -2.3)", -2.3);
        assertFunction("least(-1.5, -2.3, -5/3)", -2.3);
        assertFunction("least(1.5, -1.0 / 0.0, 1.0 / 0.0)".);
        // mixed
        assertFunction("least(1, 2.0)", 1.0);
        assertFunction("least(1.0, 2)", 1.0);
    }
    @Test(expectedExceptions = PrestoException.class, expectedExceptionsMessageRegExp = "\\QInvalid argument to greatest(): NaN\\E")
    public void testGreatestWithNaN()
            throws Exception
    {
        .tryEvaluate("greatest(1.5, 0.0 / 0.0)");
    }
    @Test(expectedExceptions = PrestoException.class, expectedExceptionsMessageRegExp = "\\QInvalid argument to least(): NaN\\E")
    public void testLeastWithNaN()
            throws Exception
    {
        .tryEvaluate("least(1.5, 0.0 / 0.0)");
    }
    private void assertFunction(String projectionObject expected)
    {
        .assertFunction(projectionexpected);
    }
New to GrepCode? Check out our FAQ X