<commit_before><?xml version="1.0" encoding="UTF-8"?><!--
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.
-->
<!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN" "concept.dtd">
<concept id="math_functions">

  <title>Impala Mathematical Functions</title>
  <titlealts audience="PDF"><navtitle>Mathematical Functions</navtitle></titlealts>
  <prolog>
    <metadata>
      <data name="Category" value="Impala"/>
      <data name="Category" value="Impala Functions"/>
      <data name="Category" value="SQL"/>
      <data name="Category" value="Data Analysts"/>
      <data name="Category" value="Developers"/>
      <data name="Category" value="Querying"/>
    </metadata>
  </prolog>

  <conbody>

    <p>
      Mathematical functions, or arithmetic functions, perform numeric calculations that are typically more complex
      than basic addition, subtraction, multiplication, and division. For example, these functions include
      trigonometric, logarithmic, and base conversion operations.
    </p>

    <note>
      In Impala, exponentiation uses the <codeph>pow()</codeph> function rather than an exponentiation operator
      such as <codeph>**</codeph>.
    </note>

    <p conref="../shared/impala_common.xml#common/related_info"/>

    <p>
      The mathematical functions operate mainly on these data types: <xref href="impala_int.xml#int"/>,
      <xref href="impala_bigint.xml#bigint"/>, <xref href="impala_smallint.xml#smallint"/>,
      <xref href="impala_tinyint.xml#tinyint"/>, <xref href="impala_double.xml#double"/>,
      <xref href="impala_float.xml#float"/>, and <xref href="impala_decimal.xml#decimal"/>. For the operators that
      perform the standard operations such as addition, subtraction, multiplication, and division, see
      <xref href="impala_operators.xml#arithmetic_operators"/>.
    </p>

    <p>
      Functions that perform bitwise operations are explained in <xref href="impala_bit_functions.xml#bit_functions"/>.
    </p>

    <p>
      <b>Function reference:</b>
    </p>

    <p>
      Impala supports the following mathematical functions:
    </p>

    <dl>
      <dlentry rev="1.4.0" id="abs">

        <dt rev="1.4.0 2.0.1">
          <codeph>abs(numeric_type a)</codeph>
<!-- <codeph>abs(double a), abs(decimal(p,s) a)</codeph> -->
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">abs() function</indexterm>
          <b>Purpose:</b> Returns the absolute value of the argument.
          <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/>
          <p>
            <b>Usage notes:</b> Use this function to ensure all return values are positive. This is different than
            the <codeph>positive()</codeph> function, which returns its argument unchanged (even if the argument
            was negative).
          </p>
        </dd>

      </dlentry>

      <dlentry id="acos">

        <dt>
          <codeph>acos(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">acos() function</indexterm>
          <b>Purpose:</b> Returns the arccosine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="asin">

        <dt>
          <codeph>asin(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">asin() function</indexterm>
          <b>Purpose:</b> Returns the arcsine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="atan">

        <dt>
          <codeph>atan(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">atan() function</indexterm>
          <b>Purpose:</b> Returns the arctangent of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="atan2" rev="2.3.0 IMPALA-1771">

        <dt rev="2.3.0 IMPALA-1771">
          <codeph>atan2(double a, double b)</codeph>
        </dt>

        <dd rev="2.3.0 IMPALA-1771">
          <indexterm audience="hidden">atan2() function</indexterm>
          <b>Purpose:</b> Returns the arctangent of the two arguments, with the signs of the arguments used to determine the
          quadrant of the result.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="bin">

        <dt>
          <codeph>bin(bigint a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">bin() function</indexterm>
          <b>Purpose:</b> Returns the binary representation of an integer value, that is, a string of 0 and 1
          digits.
          <p>
            <b>Return type:</b> <codeph>string</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="ceil">

        <dt rev="1.4.0">
          <codeph>ceil(double a)</codeph>,
          <codeph>ceil(decimal(p,s) a)</codeph>,
          <codeph id="ceiling">ceiling(double a)</codeph>,
          <codeph>ceiling(decimal(p,s) a)</codeph>,
          <codeph id="dceil" rev="2.3.0">dceil(double a)</codeph>,
          <codeph rev="2.3.0">dceil(decimal(p,s) a)</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">ceil() function</indexterm>
          <b>Purpose:</b> Returns the smallest integer that is greater than or equal to the argument.
          <p>
            <b>Return type:</b> Same as the input value
          </p>
        </dd>

      </dlentry>

      <dlentry id="conv">

        <dt>
          <codeph>conv(bigint num, int from_base, int to_base), conv(string num, int from_base, int
          to_base)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">conv() function</indexterm>
          <b>Purpose:</b> Returns a string representation of an integer value in a particular base. The input value
          can be a string, for example to convert a hexadecimal number such as <codeph>fce2</codeph> to decimal. To
          use the return value as a number (for example, when converting to base 10), use <codeph>CAST()</codeph>
          to convert to the appropriate type.
          <p>
            <b>Return type:</b> <codeph>string</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="cos">

        <dt>
          <codeph>cos(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">cos() function</indexterm>
          <b>Purpose:</b> Returns the cosine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="cosh" rev="2.3.0 IMPALA-1771">

        <dt rev="2.3.0 IMPALA-1771">
          <codeph>cosh(double a)</codeph>
        </dt>

        <dd rev="2.3.0 IMPALA-1771">
          <indexterm audience="hidden">cosh() function</indexterm>
          <b>Purpose:</b> Returns the hyperbolic cosine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="cot" rev="2.3.0 IMPALA-1771">

        <dt rev="2.3.0 IMPALA-1771">
          <codeph>cot(double a)</codeph>
        </dt>

        <dd rev="2.3.0 IMPALA-1771">
          <indexterm audience="hidden">cot() function</indexterm>
          <b>Purpose:</b> Returns the cotangent of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/added_in_230"/>
        </dd>

      </dlentry>

      <dlentry id="degrees">

        <dt>
          <codeph>degrees(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">degrees() function</indexterm>
          <b>Purpose:</b> Converts argument value from radians to degrees.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="e">

        <dt>
          <codeph>e()</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">e() function</indexterm>
          <b>Purpose:</b> Returns the
          <xref href="https://en.wikipedia.org/wiki/E_(mathematical_constant" scope="external" format="html">mathematical
          constant e</xref>.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="exp">

        <dt>
          <codeph>exp(double a)</codeph>,
          <codeph rev="2.3.0" id="dexp">dexp(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">exp() function</indexterm>
          <b>Purpose:</b> Returns the
          <xref href="https://en.wikipedia.org/wiki/E_(mathematical_constant" scope="external" format="html">mathematical
          constant e</xref> raised to the power of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="2.3.0" id="factorial">

        <dt rev="2.3.0">
          <codeph>factorial(integer_type a)</codeph>
        </dt>
        <dd rev="2.3.0">
          <indexterm audience="hidden">factorial() function</indexterm>
          <b>Purpose:</b> Computes the <xref href="https://en.wikipedia.org/wiki/Factorial" scope="external" format="html">factorial</xref> of an integer value.
          It works with any integer type.
          <p conref="../shared/impala_common.xml#common/added_in_230"/>
          <p>
            <b>Usage notes:</b> You can use either the <codeph>factorial()</codeph> function or the <codeph>!</codeph> operator.
            The factorial of 0 is 1. Likewise, the <codeph>factorial()</codeph> function returns 1 for any negative value.
            The maximum positive value for the input argument is 20; a value of 21 or greater overflows the
            range for a <codeph>BIGINT</codeph> and causes an error.
          </p>
          <p>
            <b>Return type:</b> <codeph>bigint</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/added_in_230"/>
<codeblock>select factorial(5);
+--------------+
| factorial(5) |
+--------------+
| 120          |
+--------------+

select 5!;
+-----+
| 5!  |
+-----+
| 120 |
+-----+

select factorial(0);
+--------------+
| factorial(0) |
+--------------+
| 1            |
+--------------+

select factorial(-100);
+-----------------+
| factorial(-100) |
+-----------------+
| 1               |
+-----------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry id="floor">

        <dt>
          <codeph>floor(double a)</codeph>,
          <codeph>floor(decimal(p,s) a)</codeph>,
          <codeph rev="2.3.0" id="dfloor">dfloor(double a)</codeph>,
          <codeph rev="2.3.0">dfloor(decimal(p,s) a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">floor() function</indexterm>
          <b>Purpose:</b> Returns the largest integer that is less than or equal to the argument.
          <p>
            <b>Return type:</b> Same as the input type
          </p>
        </dd>

      </dlentry>

      <dlentry id="fmod">

        <dt>
          <codeph>fmod(double a, double b), fmod(float a, float b)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">fmod() function</indexterm>
          <b>Purpose:</b> Returns the modulus of a floating-point number. Equivalent to the <codeph>%</codeph> arithmetic operator.
          <p>
            <b>Return type:</b> <codeph>float</codeph> or <codeph>double</codeph>, depending on type of arguments
          </p>
          <p conref="../shared/impala_common.xml#common/added_in_111"/>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            Because this function operates on <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph>
            values, it is subject to potential rounding errors for values that cannot be
            represented precisely. Prefer to use whole numbers, or values that you know
            can be represented precisely by the <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph>
            types.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show equivalent operations with the <codeph>fmod()</codeph>
            function and the <codeph>%</codeph> arithmetic operator, for values not subject
            to any rounding error.
          </p>
<codeblock>select fmod(10,3);
+-------------+
| fmod(10, 3) |
+-------------+
| 1           |
+-------------+

select fmod(5.5,2);
+--------------+
| fmod(5.5, 2) |
+--------------+
| 1.5          |
+--------------+

select 10 % 3;
+--------+
| 10 % 3 |
+--------+
| 1      |
+--------+

select 5.5 % 2;
+---------+
| 5.5 % 2 |
+---------+
| 1.5     |
+---------+
</codeblock>
          <p>
            The following examples show operations with the <codeph>fmod()</codeph>
            function for values that cannot be represented precisely by the
            <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph> types, and thus are
            subject to rounding error. <codeph>fmod(9.9,3.0)</codeph> returns a value
            slightly different than the expected 0.9 because of rounding.
            <codeph>fmod(9.9,3.3)</codeph> returns a value quite different from
            the expected value of 0 because of rounding error during intermediate
            calculations.
          </p>
<codeblock>select fmod(9.9,3.0);
+--------------------+
| fmod(9.9, 3.0)     |
+--------------------+
| 0.8999996185302734 |
+--------------------+

select fmod(9.9,3.3);
+-------------------+
| fmod(9.9, 3.3)    |
+-------------------+
| 3.299999713897705 |
+-------------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry rev="1.2.2" id="fnv_hash">

        <dt rev="1.2.2">
          <codeph>fnv_hash(type v)</codeph>,
        </dt>

        <dd rev="1.2.2">
          <indexterm audience="hidden">fnv_hash() function</indexterm>
          <b>Purpose:</b> Returns a consistent 64-bit value derived from the input argument, for convenience of
          implementing hashing logic in an application.
          <p>
            <b>Return type:</b> <codeph>BIGINT</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            You might use the return value in an application where you perform load balancing, bucketing, or some
            other technique to divide processing or storage.
          </p>
          <p>
            Because the result can be any 64-bit value, to restrict the value to a particular range, you can use an
            expression that includes the <codeph>ABS()</codeph> function and the <codeph>%</codeph> (modulo)
            operator. For example, to produce a hash value in the range 0-9, you could use the expression
            <codeph>ABS(FNV_HASH(x)) % 10</codeph>.
          </p>
          <p>
            This function implements the same algorithm that Impala uses internally for hashing, on systems where
            the CRC32 instructions are not available.
          </p>
          <p>
            This function implements the
            <xref href="http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function" scope="external" format="html">Fowler–Noll–Vo
            hash function</xref>, in particular the FNV-1a variation. This is not a perfect hash function: some
            combinations of values could produce the same result value. It is not suitable for cryptographic use.
          </p>
          <p>
            Similar input values of different types could produce different hash values, for example the same
            numeric value represented as <codeph>SMALLINT</codeph> or <codeph>BIGINT</codeph>,
            <codeph>FLOAT</codeph> or <codeph>DOUBLE</codeph>, or <codeph>DECIMAL(5,2)</codeph> or
            <codeph>DECIMAL(20,5)</codeph>.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
<codeblock>[localhost:21000] &gt; create table h (x int, s string);
[localhost:21000] &gt; insert into h values (0, 'hello'), (1,'world'), (1234567890,'antidisestablishmentarianism');
[localhost:21000] &gt; select x, fnv_hash(x) from h;
+------------+----------------------+
| x          | fnv_hash(x)          |
+------------+----------------------+
| 0          | -2611523532599129963 |
| 1          | 4307505193096137732  |
| 1234567890 | 3614724209955230832  |
+------------+----------------------+
[localhost:21000] &gt; select s, fnv_hash(s) from h;
+------------------------------+---------------------+
| s                            | fnv_hash(s)         |
+------------------------------+---------------------+
| hello                        | 6414202926103426347 |
| world                        | 6535280128821139475 |
| antidisestablishmentarianism | -209330013948433970 |
+------------------------------+---------------------+
[localhost:21000] &gt; select s, abs(fnv_hash(s)) % 10 from h;
+------------------------------+-------------------------+
| s                            | abs(fnv_hash(s)) % 10.0 |
+------------------------------+-------------------------+
| hello                        | 8                       |
| world                        | 6                       |
| antidisestablishmentarianism | 4                       |
+------------------------------+-------------------------+</codeblock>
          <p>
            For short argument values, the high-order bits of the result have relatively low entropy:
          </p>
<codeblock>[localhost:21000] &gt; create table b (x boolean);
[localhost:21000] &gt; insert into b values (true), (true), (false), (false);
[localhost:21000] &gt; select x, fnv_hash(x) from b;
+-------+---------------------+
| x     | fnv_hash(x)         |
+-------+---------------------+
| true  | 2062020650953872396 |
| true  | 2062020650953872396 |
| false | 2062021750465500607 |
| false | 2062021750465500607 |
+-------+---------------------+</codeblock>
          <p>
            <b>Added in:</b> Impala 1.2.2
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="greatest">

        <dt rev="1.4.0">
          <codeph>greatest(bigint a[, bigint b ...])</codeph>, <codeph>greatest(double a[, double b ...])</codeph>,
          <codeph>greatest(decimal(p,s) a[, decimal(p,s) b ...])</codeph>, <codeph>greatest(string a[, string b
          ...])</codeph>, <codeph>greatest(timestamp a[, timestamp b ...])</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">greatest() function</indexterm>
          <b>Purpose:</b> Returns the largest value from a list of expressions.
          <p conref="../shared/impala_common.xml#common/return_same_type"/>
        </dd>

      </dlentry>

      <dlentry id="hex">

        <dt>
          <codeph>hex(bigint a), hex(string a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">hex() function</indexterm>
          <b>Purpose:</b> Returns the hexadecimal representation of an integer value, or of the characters in a
          string.
          <p>
            <b>Return type:</b> <codeph>string</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="is_inf">

        <dt rev="1.4.0">
          <codeph>is_inf(double a)</codeph>,
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">is_inf() function</indexterm>
          <b>Purpose:</b> Tests whether a value is equal to the special value <q>inf</q>, signifying infinity.
          <p>
            <b>Return type:</b> <codeph>boolean</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p conref="../shared/impala_common.xml#common/infinity_and_nan"/>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="is_nan">

        <dt rev="1.4.0">
          <codeph>is_nan(double a)</codeph>,
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">is_nan() function</indexterm>
          <b>Purpose:</b> Tests whether a value is equal to the special value <q>NaN</q>, signifying <q>not a
          number</q>.
          <p>
            <b>Return type:</b> <codeph>boolean</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p conref="../shared/impala_common.xml#common/infinity_and_nan"/>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="least">

        <dt rev="1.4.0">
          <codeph>least(bigint a[, bigint b ...])</codeph>, <codeph>least(double a[, double b ...])</codeph>,
          <codeph>least(decimal(p,s) a[, decimal(p,s) b ...])</codeph>, <codeph>least(string a[, string b
          ...])</codeph>, <codeph>least(timestamp a[, timestamp b ...])</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">least() function</indexterm>
          <b>Purpose:</b> Returns the smallest value from a list of expressions.
          <p conref="../shared/impala_common.xml#common/return_same_type"/>
        </dd>

      </dlentry>

      <dlentry id="ln">

        <dt>
          <codeph>ln(double a)</codeph>,
          <codeph rev="2.3.0" id="dlog1">dlog1(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">ln() function</indexterm>
          <indexterm audience="hidden">dlog1() function</indexterm>
          <b>Purpose:</b> Returns the
          <xref href="https://en.wikipedia.org/wiki/Natural_logarithm" scope="external" format="html">natural
          logarithm</xref> of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="log">

        <dt>
          <codeph>log(double base, double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">log() function</indexterm>
          <b>Purpose:</b> Returns the logarithm of the second argument to the specified base.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="log10">

        <dt>
          <codeph>log10(double a)</codeph>,
          <codeph rev="2.3.0" id="dlog10">dlog10(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">log10() function</indexterm>
          <indexterm audience="hidden">dlog10() function</indexterm>
          <b>Purpose:</b> Returns the logarithm of the argument to the base 10.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="log2">

        <dt>
          <codeph>log2(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">log2() function</indexterm>
          <b>Purpose:</b> Returns the logarithm of the argument to the base 2.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="max_int">

        <dt rev="1.4.0">
          <codeph>max_int(), <ph id="max_tinyint">max_tinyint()</ph>, <ph id="max_smallint">max_smallint()</ph>,
          <ph id="max_bigint">max_bigint()</ph></codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">max_int() function</indexterm>
          <indexterm audience="hidden">max_tinyint() function</indexterm>
          <indexterm audience="hidden">max_smallint() function</indexterm>
          <indexterm audience="hidden">max_bigint() function</indexterm>
          <b>Purpose:</b> Returns the largest value of the associated integral type.
          <p>
            <b>Return type:</b> The same as the integral type being checked.
          </p>
          <p>
<!-- Repeated usage text between max_ and min_ functions, could turn into a conref. -->
            <b>Usage notes:</b> Use the corresponding <codeph>min_</codeph> and <codeph>max_</codeph> functions to
            check if all values in a column are within the allowed range, before copying data or altering column
            definitions. If not, switch to the next higher integral type or to a <codeph>DECIMAL</codeph> with
            sufficient precision.
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="min_int">

        <dt rev="1.4.0">
          <codeph>min_int(), <ph id="min_tinyint">min_tinyint()</ph>, <ph id="min_smallint">min_smallint()</ph>,
          <ph id="min_bigint">min_bigint()</ph></codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">min_int() function</indexterm>
          <indexterm audience="hidden">min_tinyint() function</indexterm>
          <indexterm audience="hidden">min_smallint() function</indexterm>
          <indexterm audience="hidden">min_bigint() function</indexterm>
          <b>Purpose:</b> Returns the smallest value of the associated integral type (a negative number).
          <p>
            <b>Return type:</b> The same as the integral type being checked.
          </p>
          <p>
            <b>Usage notes:</b> Use the corresponding <codeph>min_</codeph> and <codeph>max_</codeph> functions to
            check if all values in a column are within the allowed range, before copying data or altering column
            definitions. If not, switch to the next higher integral type or to a <codeph>DECIMAL</codeph> with
            sufficient precision.
          </p>
        </dd>

      </dlentry>

      <dlentry id="mod" rev="2.2.0">

        <dt rev="2.2.0">
          <codeph>mod(<varname>numeric_type</varname> a, <varname>same_type</varname> b)</codeph>
        </dt>

        <dd rev="2.2.0">
          <indexterm audience="hidden">mod() function</indexterm>
          <b>Purpose:</b> Returns the modulus of a number. Equivalent to the <codeph>%</codeph> arithmetic operator.
          Works with any size integer type, any size floating-point type, and <codeph>DECIMAL</codeph>
          with any precision and scale.
          <p conref="../shared/impala_common.xml#common/return_type_same"/>
          <p conref="../shared/impala_common.xml#common/added_in_220"/>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            Because this function works with <codeph>DECIMAL</codeph> values, prefer it over <codeph>fmod()</codeph>
            when working with fractional values. It is not subject to the rounding errors that make
            <codeph>fmod()</codeph> problematic with floating-point numbers.
            The <codeph>%</codeph> arithmetic operator now uses the <codeph>mod()</codeph> function
            in cases where its arguments can be interpreted as <codeph>DECIMAL</codeph> values,
            increasing the accuracy of that operator.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show how the <codeph>mod()</codeph> function works for
            whole numbers and fractional values, and how the <codeph>%</codeph> operator
            works the same way. In the case of <codeph>mod(9.9,3)</codeph>,
            the type conversion for the second argument results in the first argument
            being interpreted as <codeph>DOUBLE</codeph>, so to produce an accurate
            <codeph>DECIMAL</codeph> result requires casting the second argument
            or writing it as a <codeph>DECIMAL</codeph> literal, 3.0.
          </p>
<codeblock>select mod(10,3);
+-------------+
| fmod(10, 3) |
+-------------+
| 1           |
+-------------+

select mod(5.5,2);
+--------------+
| fmod(5.5, 2) |
+--------------+
| 1.5          |
+--------------+

select 10 % 3;
+--------+
| 10 % 3 |
+--------+
| 1      |
+--------+

select 5.5 % 2;
+---------+
| 5.5 % 2 |
+---------+
| 1.5     |
+---------+

select mod(9.9,3.3);
+---------------+
| mod(9.9, 3.3) |
+---------------+
| 0.0           |
+---------------+

select mod(9.9,3);
+--------------------+
| mod(9.9, 3)        |
+--------------------+
| 0.8999996185302734 |
+--------------------+

select mod(9.9, cast(3 as decimal(2,1)));
+-----------------------------------+
| mod(9.9, cast(3 as decimal(2,1))) |
+-----------------------------------+
| 0.9                               |
+-----------------------------------+

select mod(9.9,3.0);
+---------------+
| mod(9.9, 3.0) |
+---------------+
| 0.9           |
+---------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry id="murmur_hash" rev="IMPALA-3651 2.12.0">

        <dt rev="2.12.0">
          <codeph>murmur_hash(type v)</codeph>
        </dt>

        <dd rev="2.12.0">
          <indexterm audience="hidden">murmur_hash() function</indexterm>
          <b>Purpose:</b> Returns a consistent 64-bit value derived from the input argument, for convenience of
          implementing <xref keyref="MurmurHash"> MurmurHash2</xref> non-cryptographic hash function.
          <p>
            <b>Return type:</b> <codeph>BIGINT</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            You might use the return value in an application where you perform load balancing, bucketing, or some
            other technique to divide processing or storage. This function provides a good performance for all kinds
            of keys such as number, ascii string and UTF-8. It can be recommended as general-purpose hashing function.
          </p>
          <p>
            Regarding comparison of murmur_hash with fnv_hash, murmur_hash is based on Murmur2 hash algorithm and fnv_hash
            function is based on FNV-1a hash algorithm. Murmur2 and FNV-1a can show very good randomness and performance
            compared with well known other hash algorithms, but Murmur2 slightly show better randomness and performance than FNV-1a.
            See <xref keyref="hash_functions1">[1]</xref><xref keyref="hash_functions2">[2]</xref><xref keyref="hash_functions1">[3]</xref> for details.
          </p>
          <p>
            Similar input values of different types could produce different hash values, for example the same
            numeric value represented as <codeph>SMALLINT</codeph> or <codeph>BIGINT</codeph>,
            <codeph>FLOAT</codeph> or <codeph>DOUBLE</codeph>, or <codeph>DECIMAL(5,2)</codeph> or
            <codeph>DECIMAL(20,5)</codeph>.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
<codeblock>[localhost:21000] &gt; create table h (x int, s string);
[localhost:21000] &gt; insert into h values (0, 'hello'), (1,'world'), (1234567890,'antidisestablishmentarianism');
[localhost:21000] &gt; select x, murmur_hash(x) from h;
+------------+----------------------+
| x          | murmur_hash(x)       |
+------------+----------------------+
| 0          | 6960269033020761575  |
| 1          | -780611581681153783  |
| 1234567890 | -5754914572385924334 |
+------------+----------------------+
[localhost:21000] &gt; select s, murmur_hash(s) from h;
+------------------------------+----------------------+
| s                            | murmur_hash(s)       |
+------------------------------+----------------------+
| hello                        | 2191231550387646743  |
| world                        | 5568329560871645431  |
| antidisestablishmentarianism | -2261804666958489663 |
+------------------------------+----------------------+ </codeblock>
          <p>
            For short argument values, the high-order bits of the result have relatively higher entropy than fnv_hash:
          </p>
<codeblock>[localhost:21000] &gt; create table b (x boolean);
[localhost:21000] &gt; insert into b values (true), (true), (false), (false);
[localhost:21000] &gt; select x, murmur_hash(x) from b;
+-------+----------------------+
| x     | murmur_hash(x)       |
+-------+---------------------++
| true  | -5720937396023583481 |
| true  | -5720937396023583481 |
| false | 6351753276682545529  |
| false | 6351753276682545529  |
+-------+--------------------+-+</codeblock>
          <p>
            <b>Added in:</b> Impala 2.12.0
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="negative">

        <dt rev="2.0.1">
          <codeph>negative(numeric_type a)</codeph>
<!-- <codeph>negative(int a), negative(double a), negative(decimal(p,s) a)</codeph> -->
        </dt>

        <dd>
          <indexterm audience="hidden">negative() function</indexterm>
          <b>Purpose:</b> Returns the argument with the sign reversed; returns a positive value if the argument was
          already negative.
          <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/>
<!--
            <p>
              <b>Return type:</b> <codeph>int</codeph>, <codeph>double</codeph>,
              or <codeph>decimal(p,s)</codeph> depending on type of argument
            </p>
            -->
          <p>
            <b>Usage notes:</b> Use <codeph>-abs(a)</codeph> instead if you need to ensure all return values are
            negative.
          </p>
        </dd>

      </dlentry>

      <dlentry id="pi">

        <dt rev="1.4.0">
          <codeph>pi()</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">pi() function</indexterm>
          <b>Purpose:</b> Returns the constant pi.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="pmod">

        <dt>
          <codeph>pmod(bigint a, bigint b), pmod(double a, double b)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">pmod() function</indexterm>
          <b>Purpose:</b> Returns the positive modulus of a number.
          Primarily for <xref href="https://issues.apache.org/jira/browse/HIVE-656" scope="external" format="html">HiveQL compatibility</xref>.
          <p>
            <b>Return type:</b> <codeph>int</codeph> or <codeph>double</codeph>, depending on type of arguments
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show how the <codeph>fmod()</codeph> function sometimes returns a negative value
            depending on the sign of its arguments, and the <codeph>pmod()</codeph> function returns the same value
            as <codeph>fmod()</codeph>, but sometimes with the sign flipped.
          </p>
<codeblock>select fmod(-5,2);
+-------------+
| fmod(-5, 2) |
+-------------+
| -1          |
+-------------+

select pmod(-5,2);
+-------------+
| pmod(-5, 2) |
+-------------+
| 1           |
+-------------+

select fmod(-5,-2);
+--------------+
| fmod(-5, -2) |
+--------------+
| -1           |
+--------------+

select pmod(-5,-2);
+--------------+
| pmod(-5, -2) |
+--------------+
| -1           |
+--------------+

select fmod(5,-2);
+-------------+
| fmod(5, -2) |
+-------------+
| 1           |
+-------------+

select pmod(5,-2);
+-------------+
| pmod(5, -2) |
+-------------+
| -1          |
+-------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="positive">

        <dt rev="2.0.1">
          <codeph>positive(numeric_type a)</codeph>
<!-- <codeph>positive(int a), positive(double a), positive(decimal(p,s) a</codeph> -->
        </dt>

        <dd>
          <indexterm audience="hidden">positive() function</indexterm>
          <b>Purpose:</b> Returns the original argument unchanged (even if the argument is negative).
          <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/>
<!--
            <p>
              <b>Return type:</b> <codeph>int</codeph>, <codeph>double</codeph>,
              or <codeph>decimal(p,s)</codeph> depending on type of argument
            </p>
            -->
          <p>
            <b>Usage notes:</b> Use <codeph>abs()</codeph> instead if you need to ensure all return values are
            positive.
          </p>
        </dd>

      </dlentry>

      <dlentry id="pow">

        <dt rev="1.4.0">
          <codeph>pow(double a, double p)</codeph>,
          <codeph id="power">power(double a, double p)</codeph>,
          <codeph rev="2.3.0" id="dpow">dpow(double a, double p)</codeph>,
          <codeph rev="2.3.0" id="fpow">fpow(double a, double p)</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">pow() function</indexterm>
          <indexterm audience="hidden">power() function</indexterm>
          <indexterm audience="hidden">dpow() function</indexterm>
          <indexterm audience="hidden">fpow() function</indexterm>
          <b>Purpose:</b> Returns the first argument raised to the power of the second argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="precision">

        <dt rev="1.4.0">
          <codeph>precision(<varname>numeric_expression</varname>)</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">precision() function</indexterm>
          <b>Purpose:</b> Computes the precision (number of decimal digits) needed to represent the type of the
          argument expression as a <codeph>DECIMAL</codeph> value.
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            Typically used in combination with the <codeph>scale()</codeph> function, to determine the appropriate
            <codeph>DECIMAL(<varname>precision</varname>,<varname>scale</varname>)</codeph> type to declare in a
            <codeph>CREATE TABLE</codeph> statement or <codeph>CAST()</codeph> function.
          </p>
          <p>
            <b>Return type:</b> <codeph>int</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p conref="../shared/impala_common.xml#common/precision_scale_example"/>
        </dd>

      </dlentry>

      <dlentry id="quotient">

        <dt>
          <codeph>quotient(bigint numerator, bigint denominator)</codeph>,
          <codeph>quotient(double numerator, double denominator)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">quotient() function</indexterm>
          <b>Purpose:</b> Returns the first argument divided by the second argument, discarding any fractional
          part. Avoids promoting integer arguments to <codeph>DOUBLE</codeph> as happens with the <codeph>/</codeph> SQL
          operator. <ph rev="IMPALA-278">Also includes an overload that accepts <codeph>DOUBLE</codeph> arguments,
          discards the fractional part of each argument value before dividing, and again returns <codeph>BIGINT</codeph>.
          With integer arguments, this function works the same as the <codeph>DIV</codeph> operator.</ph>
          <p>
            <b>Return type:</b> <codeph>bigint</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="radians">

        <dt>
          <codeph>radians(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">radians() function</indexterm>
          <b>Purpose:</b> Converts argument value from degrees to radians.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="rand">

        <dt>
          <codeph>rand()</codeph>, <codeph>rand(int seed)</codeph>,
          <codeph rev="2.3.0" id="random">random()</codeph>,
          <codeph rev="2.3.0">random(int seed)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">rand() function</indexterm>
          <b>Purpose:</b> Returns a random value between 0 and 1. After <codeph>rand()</codeph> is called with a
          seed argument, it produces a consistent random sequence based on the seed value.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
          <p>
            <b>Usage notes:</b> Currently, the random sequence is reset after each query, and multiple calls to
            <codeph>rand()</codeph> within the same query return the same value each time. For different number
            sequences that are different for each query, pass a unique seed value to each call to
            <codeph>rand()</codeph>. For example, <codeph>select rand(unix_timestamp()) from ...</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show how <codeph>rand()</codeph> can produce sequences of varying predictability,
            so that you can reproduce query results involving random values or generate unique sequences of random
            values for each query.
            When <codeph>rand()</codeph> is called with no argument, it generates the same sequence of values each time,
            regardless of the ordering of the result set.
            When <codeph>rand()</codeph> is called with a constant integer, it generates a different sequence of values,
            but still always the same sequence for the same seed value.
            If you pass in a seed value that changes, such as the return value of the expression <codeph>unix_timestamp(now())</codeph>,<commit_msg>IMPALA-6174: [DOCS] Fixed the seed data type for RAND and RANDOM functions<commit_after><?xml version="1.0" encoding="UTF-8"?><!--
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.
-->
<!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN" "concept.dtd">
<concept id="math_functions">

  <title>Impala Mathematical Functions</title>
  <titlealts audience="PDF"><navtitle>Mathematical Functions</navtitle></titlealts>
  <prolog>
    <metadata>
      <data name="Category" value="Impala"/>
      <data name="Category" value="Impala Functions"/>
      <data name="Category" value="SQL"/>
      <data name="Category" value="Data Analysts"/>
      <data name="Category" value="Developers"/>
      <data name="Category" value="Querying"/>
    </metadata>
  </prolog>

  <conbody>

    <p>
      Mathematical functions, or arithmetic functions, perform numeric calculations that are typically more complex
      than basic addition, subtraction, multiplication, and division. For example, these functions include
      trigonometric, logarithmic, and base conversion operations.
    </p>

    <note>
      In Impala, exponentiation uses the <codeph>pow()</codeph> function rather than an exponentiation operator
      such as <codeph>**</codeph>.
    </note>

    <p conref="../shared/impala_common.xml#common/related_info"/>

    <p>
      The mathematical functions operate mainly on these data types: <xref href="impala_int.xml#int"/>,
      <xref href="impala_bigint.xml#bigint"/>, <xref href="impala_smallint.xml#smallint"/>,
      <xref href="impala_tinyint.xml#tinyint"/>, <xref href="impala_double.xml#double"/>,
      <xref href="impala_float.xml#float"/>, and <xref href="impala_decimal.xml#decimal"/>. For the operators that
      perform the standard operations such as addition, subtraction, multiplication, and division, see
      <xref href="impala_operators.xml#arithmetic_operators"/>.
    </p>

    <p>
      Functions that perform bitwise operations are explained in <xref href="impala_bit_functions.xml#bit_functions"/>.
    </p>

    <p>
      <b>Function reference:</b>
    </p>

    <p>
      Impala supports the following mathematical functions:
    </p>

    <dl>
      <dlentry rev="1.4.0" id="abs">

        <dt rev="1.4.0 2.0.1">
          <codeph>abs(numeric_type a)</codeph>
<!-- <codeph>abs(double a), abs(decimal(p,s) a)</codeph> -->
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">abs() function</indexterm>
          <b>Purpose:</b> Returns the absolute value of the argument.
          <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/>
          <p>
            <b>Usage notes:</b> Use this function to ensure all return values are positive. This is different than
            the <codeph>positive()</codeph> function, which returns its argument unchanged (even if the argument
            was negative).
          </p>
        </dd>

      </dlentry>

      <dlentry id="acos">

        <dt>
          <codeph>acos(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">acos() function</indexterm>
          <b>Purpose:</b> Returns the arccosine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="asin">

        <dt>
          <codeph>asin(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">asin() function</indexterm>
          <b>Purpose:</b> Returns the arcsine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="atan">

        <dt>
          <codeph>atan(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">atan() function</indexterm>
          <b>Purpose:</b> Returns the arctangent of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="atan2" rev="2.3.0 IMPALA-1771">

        <dt rev="2.3.0 IMPALA-1771">
          <codeph>atan2(double a, double b)</codeph>
        </dt>

        <dd rev="2.3.0 IMPALA-1771">
          <indexterm audience="hidden">atan2() function</indexterm>
          <b>Purpose:</b> Returns the arctangent of the two arguments, with the signs of the arguments used to determine the
          quadrant of the result.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="bin">

        <dt>
          <codeph>bin(bigint a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">bin() function</indexterm>
          <b>Purpose:</b> Returns the binary representation of an integer value, that is, a string of 0 and 1
          digits.
          <p>
            <b>Return type:</b> <codeph>string</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="ceil">

        <dt rev="1.4.0">
          <codeph>ceil(double a)</codeph>,
          <codeph>ceil(decimal(p,s) a)</codeph>,
          <codeph id="ceiling">ceiling(double a)</codeph>,
          <codeph>ceiling(decimal(p,s) a)</codeph>,
          <codeph id="dceil" rev="2.3.0">dceil(double a)</codeph>,
          <codeph rev="2.3.0">dceil(decimal(p,s) a)</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">ceil() function</indexterm>
          <b>Purpose:</b> Returns the smallest integer that is greater than or equal to the argument.
          <p>
            <b>Return type:</b> Same as the input value
          </p>
        </dd>

      </dlentry>

      <dlentry id="conv">

        <dt>
          <codeph>conv(bigint num, int from_base, int to_base), conv(string num, int from_base, int
          to_base)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">conv() function</indexterm>
          <b>Purpose:</b> Returns a string representation of an integer value in a particular base. The input value
          can be a string, for example to convert a hexadecimal number such as <codeph>fce2</codeph> to decimal. To
          use the return value as a number (for example, when converting to base 10), use <codeph>CAST()</codeph>
          to convert to the appropriate type.
          <p>
            <b>Return type:</b> <codeph>string</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="cos">

        <dt>
          <codeph>cos(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">cos() function</indexterm>
          <b>Purpose:</b> Returns the cosine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="cosh" rev="2.3.0 IMPALA-1771">

        <dt rev="2.3.0 IMPALA-1771">
          <codeph>cosh(double a)</codeph>
        </dt>

        <dd rev="2.3.0 IMPALA-1771">
          <indexterm audience="hidden">cosh() function</indexterm>
          <b>Purpose:</b> Returns the hyperbolic cosine of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="cot" rev="2.3.0 IMPALA-1771">

        <dt rev="2.3.0 IMPALA-1771">
          <codeph>cot(double a)</codeph>
        </dt>

        <dd rev="2.3.0 IMPALA-1771">
          <indexterm audience="hidden">cot() function</indexterm>
          <b>Purpose:</b> Returns the cotangent of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/added_in_230"/>
        </dd>

      </dlentry>

      <dlentry id="degrees">

        <dt>
          <codeph>degrees(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">degrees() function</indexterm>
          <b>Purpose:</b> Converts argument value from radians to degrees.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="e">

        <dt>
          <codeph>e()</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">e() function</indexterm>
          <b>Purpose:</b> Returns the
          <xref href="https://en.wikipedia.org/wiki/E_(mathematical_constant" scope="external" format="html">mathematical
          constant e</xref>.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="exp">

        <dt>
          <codeph>exp(double a)</codeph>,
          <codeph rev="2.3.0" id="dexp">dexp(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">exp() function</indexterm>
          <b>Purpose:</b> Returns the
          <xref href="https://en.wikipedia.org/wiki/E_(mathematical_constant" scope="external" format="html">mathematical
          constant e</xref> raised to the power of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="2.3.0" id="factorial">

        <dt rev="2.3.0">
          <codeph>factorial(integer_type a)</codeph>
        </dt>
        <dd rev="2.3.0">
          <indexterm audience="hidden">factorial() function</indexterm>
          <b>Purpose:</b> Computes the <xref href="https://en.wikipedia.org/wiki/Factorial" scope="external" format="html">factorial</xref> of an integer value.
          It works with any integer type.
          <p conref="../shared/impala_common.xml#common/added_in_230"/>
          <p>
            <b>Usage notes:</b> You can use either the <codeph>factorial()</codeph> function or the <codeph>!</codeph> operator.
            The factorial of 0 is 1. Likewise, the <codeph>factorial()</codeph> function returns 1 for any negative value.
            The maximum positive value for the input argument is 20; a value of 21 or greater overflows the
            range for a <codeph>BIGINT</codeph> and causes an error.
          </p>
          <p>
            <b>Return type:</b> <codeph>bigint</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/added_in_230"/>
<codeblock>select factorial(5);
+--------------+
| factorial(5) |
+--------------+
| 120          |
+--------------+

select 5!;
+-----+
| 5!  |
+-----+
| 120 |
+-----+

select factorial(0);
+--------------+
| factorial(0) |
+--------------+
| 1            |
+--------------+

select factorial(-100);
+-----------------+
| factorial(-100) |
+-----------------+
| 1               |
+-----------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry id="floor">

        <dt>
          <codeph>floor(double a)</codeph>,
          <codeph>floor(decimal(p,s) a)</codeph>,
          <codeph rev="2.3.0" id="dfloor">dfloor(double a)</codeph>,
          <codeph rev="2.3.0">dfloor(decimal(p,s) a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">floor() function</indexterm>
          <b>Purpose:</b> Returns the largest integer that is less than or equal to the argument.
          <p>
            <b>Return type:</b> Same as the input type
          </p>
        </dd>

      </dlentry>

      <dlentry id="fmod">

        <dt>
          <codeph>fmod(double a, double b), fmod(float a, float b)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">fmod() function</indexterm>
          <b>Purpose:</b> Returns the modulus of a floating-point number. Equivalent to the <codeph>%</codeph> arithmetic operator.
          <p>
            <b>Return type:</b> <codeph>float</codeph> or <codeph>double</codeph>, depending on type of arguments
          </p>
          <p conref="../shared/impala_common.xml#common/added_in_111"/>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            Because this function operates on <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph>
            values, it is subject to potential rounding errors for values that cannot be
            represented precisely. Prefer to use whole numbers, or values that you know
            can be represented precisely by the <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph>
            types.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show equivalent operations with the <codeph>fmod()</codeph>
            function and the <codeph>%</codeph> arithmetic operator, for values not subject
            to any rounding error.
          </p>
<codeblock>select fmod(10,3);
+-------------+
| fmod(10, 3) |
+-------------+
| 1           |
+-------------+

select fmod(5.5,2);
+--------------+
| fmod(5.5, 2) |
+--------------+
| 1.5          |
+--------------+

select 10 % 3;
+--------+
| 10 % 3 |
+--------+
| 1      |
+--------+

select 5.5 % 2;
+---------+
| 5.5 % 2 |
+---------+
| 1.5     |
+---------+
</codeblock>
          <p>
            The following examples show operations with the <codeph>fmod()</codeph>
            function for values that cannot be represented precisely by the
            <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph> types, and thus are
            subject to rounding error. <codeph>fmod(9.9,3.0)</codeph> returns a value
            slightly different than the expected 0.9 because of rounding.
            <codeph>fmod(9.9,3.3)</codeph> returns a value quite different from
            the expected value of 0 because of rounding error during intermediate
            calculations.
          </p>
<codeblock>select fmod(9.9,3.0);
+--------------------+
| fmod(9.9, 3.0)     |
+--------------------+
| 0.8999996185302734 |
+--------------------+

select fmod(9.9,3.3);
+-------------------+
| fmod(9.9, 3.3)    |
+-------------------+
| 3.299999713897705 |
+-------------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry rev="1.2.2" id="fnv_hash">

        <dt rev="1.2.2">
          <codeph>fnv_hash(type v)</codeph>,
        </dt>

        <dd rev="1.2.2">
          <indexterm audience="hidden">fnv_hash() function</indexterm>
          <b>Purpose:</b> Returns a consistent 64-bit value derived from the input argument, for convenience of
          implementing hashing logic in an application.
          <p>
            <b>Return type:</b> <codeph>BIGINT</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            You might use the return value in an application where you perform load balancing, bucketing, or some
            other technique to divide processing or storage.
          </p>
          <p>
            Because the result can be any 64-bit value, to restrict the value to a particular range, you can use an
            expression that includes the <codeph>ABS()</codeph> function and the <codeph>%</codeph> (modulo)
            operator. For example, to produce a hash value in the range 0-9, you could use the expression
            <codeph>ABS(FNV_HASH(x)) % 10</codeph>.
          </p>
          <p>
            This function implements the same algorithm that Impala uses internally for hashing, on systems where
            the CRC32 instructions are not available.
          </p>
          <p>
            This function implements the
            <xref href="http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function" scope="external" format="html">Fowler–Noll–Vo
            hash function</xref>, in particular the FNV-1a variation. This is not a perfect hash function: some
            combinations of values could produce the same result value. It is not suitable for cryptographic use.
          </p>
          <p>
            Similar input values of different types could produce different hash values, for example the same
            numeric value represented as <codeph>SMALLINT</codeph> or <codeph>BIGINT</codeph>,
            <codeph>FLOAT</codeph> or <codeph>DOUBLE</codeph>, or <codeph>DECIMAL(5,2)</codeph> or
            <codeph>DECIMAL(20,5)</codeph>.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
<codeblock>[localhost:21000] &gt; create table h (x int, s string);
[localhost:21000] &gt; insert into h values (0, 'hello'), (1,'world'), (1234567890,'antidisestablishmentarianism');
[localhost:21000] &gt; select x, fnv_hash(x) from h;
+------------+----------------------+
| x          | fnv_hash(x)          |
+------------+----------------------+
| 0          | -2611523532599129963 |
| 1          | 4307505193096137732  |
| 1234567890 | 3614724209955230832  |
+------------+----------------------+
[localhost:21000] &gt; select s, fnv_hash(s) from h;
+------------------------------+---------------------+
| s                            | fnv_hash(s)         |
+------------------------------+---------------------+
| hello                        | 6414202926103426347 |
| world                        | 6535280128821139475 |
| antidisestablishmentarianism | -209330013948433970 |
+------------------------------+---------------------+
[localhost:21000] &gt; select s, abs(fnv_hash(s)) % 10 from h;
+------------------------------+-------------------------+
| s                            | abs(fnv_hash(s)) % 10.0 |
+------------------------------+-------------------------+
| hello                        | 8                       |
| world                        | 6                       |
| antidisestablishmentarianism | 4                       |
+------------------------------+-------------------------+</codeblock>
          <p>
            For short argument values, the high-order bits of the result have relatively low entropy:
          </p>
<codeblock>[localhost:21000] &gt; create table b (x boolean);
[localhost:21000] &gt; insert into b values (true), (true), (false), (false);
[localhost:21000] &gt; select x, fnv_hash(x) from b;
+-------+---------------------+
| x     | fnv_hash(x)         |
+-------+---------------------+
| true  | 2062020650953872396 |
| true  | 2062020650953872396 |
| false | 2062021750465500607 |
| false | 2062021750465500607 |
+-------+---------------------+</codeblock>
          <p>
            <b>Added in:</b> Impala 1.2.2
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="greatest">

        <dt rev="1.4.0">
          <codeph>greatest(bigint a[, bigint b ...])</codeph>, <codeph>greatest(double a[, double b ...])</codeph>,
          <codeph>greatest(decimal(p,s) a[, decimal(p,s) b ...])</codeph>, <codeph>greatest(string a[, string b
          ...])</codeph>, <codeph>greatest(timestamp a[, timestamp b ...])</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">greatest() function</indexterm>
          <b>Purpose:</b> Returns the largest value from a list of expressions.
          <p conref="../shared/impala_common.xml#common/return_same_type"/>
        </dd>

      </dlentry>

      <dlentry id="hex">

        <dt>
          <codeph>hex(bigint a), hex(string a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">hex() function</indexterm>
          <b>Purpose:</b> Returns the hexadecimal representation of an integer value, or of the characters in a
          string.
          <p>
            <b>Return type:</b> <codeph>string</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="is_inf">

        <dt rev="1.4.0">
          <codeph>is_inf(double a)</codeph>,
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">is_inf() function</indexterm>
          <b>Purpose:</b> Tests whether a value is equal to the special value <q>inf</q>, signifying infinity.
          <p>
            <b>Return type:</b> <codeph>boolean</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p conref="../shared/impala_common.xml#common/infinity_and_nan"/>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="is_nan">

        <dt rev="1.4.0">
          <codeph>is_nan(double a)</codeph>,
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">is_nan() function</indexterm>
          <b>Purpose:</b> Tests whether a value is equal to the special value <q>NaN</q>, signifying <q>not a
          number</q>.
          <p>
            <b>Return type:</b> <codeph>boolean</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p conref="../shared/impala_common.xml#common/infinity_and_nan"/>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="least">

        <dt rev="1.4.0">
          <codeph>least(bigint a[, bigint b ...])</codeph>, <codeph>least(double a[, double b ...])</codeph>,
          <codeph>least(decimal(p,s) a[, decimal(p,s) b ...])</codeph>, <codeph>least(string a[, string b
          ...])</codeph>, <codeph>least(timestamp a[, timestamp b ...])</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">least() function</indexterm>
          <b>Purpose:</b> Returns the smallest value from a list of expressions.
          <p conref="../shared/impala_common.xml#common/return_same_type"/>
        </dd>

      </dlentry>

      <dlentry id="ln">

        <dt>
          <codeph>ln(double a)</codeph>,
          <codeph rev="2.3.0" id="dlog1">dlog1(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">ln() function</indexterm>
          <indexterm audience="hidden">dlog1() function</indexterm>
          <b>Purpose:</b> Returns the
          <xref href="https://en.wikipedia.org/wiki/Natural_logarithm" scope="external" format="html">natural
          logarithm</xref> of the argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="log">

        <dt>
          <codeph>log(double base, double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">log() function</indexterm>
          <b>Purpose:</b> Returns the logarithm of the second argument to the specified base.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="log10">

        <dt>
          <codeph>log10(double a)</codeph>,
          <codeph rev="2.3.0" id="dlog10">dlog10(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">log10() function</indexterm>
          <indexterm audience="hidden">dlog10() function</indexterm>
          <b>Purpose:</b> Returns the logarithm of the argument to the base 10.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="log2">

        <dt>
          <codeph>log2(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">log2() function</indexterm>
          <b>Purpose:</b> Returns the logarithm of the argument to the base 2.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="max_int">

        <dt rev="1.4.0">
          <codeph>max_int(), <ph id="max_tinyint">max_tinyint()</ph>, <ph id="max_smallint">max_smallint()</ph>,
          <ph id="max_bigint">max_bigint()</ph></codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">max_int() function</indexterm>
          <indexterm audience="hidden">max_tinyint() function</indexterm>
          <indexterm audience="hidden">max_smallint() function</indexterm>
          <indexterm audience="hidden">max_bigint() function</indexterm>
          <b>Purpose:</b> Returns the largest value of the associated integral type.
          <p>
            <b>Return type:</b> The same as the integral type being checked.
          </p>
          <p>
<!-- Repeated usage text between max_ and min_ functions, could turn into a conref. -->
            <b>Usage notes:</b> Use the corresponding <codeph>min_</codeph> and <codeph>max_</codeph> functions to
            check if all values in a column are within the allowed range, before copying data or altering column
            definitions. If not, switch to the next higher integral type or to a <codeph>DECIMAL</codeph> with
            sufficient precision.
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="min_int">

        <dt rev="1.4.0">
          <codeph>min_int(), <ph id="min_tinyint">min_tinyint()</ph>, <ph id="min_smallint">min_smallint()</ph>,
          <ph id="min_bigint">min_bigint()</ph></codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">min_int() function</indexterm>
          <indexterm audience="hidden">min_tinyint() function</indexterm>
          <indexterm audience="hidden">min_smallint() function</indexterm>
          <indexterm audience="hidden">min_bigint() function</indexterm>
          <b>Purpose:</b> Returns the smallest value of the associated integral type (a negative number).
          <p>
            <b>Return type:</b> The same as the integral type being checked.
          </p>
          <p>
            <b>Usage notes:</b> Use the corresponding <codeph>min_</codeph> and <codeph>max_</codeph> functions to
            check if all values in a column are within the allowed range, before copying data or altering column
            definitions. If not, switch to the next higher integral type or to a <codeph>DECIMAL</codeph> with
            sufficient precision.
          </p>
        </dd>

      </dlentry>

      <dlentry id="mod" rev="2.2.0">

        <dt rev="2.2.0">
          <codeph>mod(<varname>numeric_type</varname> a, <varname>same_type</varname> b)</codeph>
        </dt>

        <dd rev="2.2.0">
          <indexterm audience="hidden">mod() function</indexterm>
          <b>Purpose:</b> Returns the modulus of a number. Equivalent to the <codeph>%</codeph> arithmetic operator.
          Works with any size integer type, any size floating-point type, and <codeph>DECIMAL</codeph>
          with any precision and scale.
          <p conref="../shared/impala_common.xml#common/return_type_same"/>
          <p conref="../shared/impala_common.xml#common/added_in_220"/>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            Because this function works with <codeph>DECIMAL</codeph> values, prefer it over <codeph>fmod()</codeph>
            when working with fractional values. It is not subject to the rounding errors that make
            <codeph>fmod()</codeph> problematic with floating-point numbers.
            The <codeph>%</codeph> arithmetic operator now uses the <codeph>mod()</codeph> function
            in cases where its arguments can be interpreted as <codeph>DECIMAL</codeph> values,
            increasing the accuracy of that operator.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show how the <codeph>mod()</codeph> function works for
            whole numbers and fractional values, and how the <codeph>%</codeph> operator
            works the same way. In the case of <codeph>mod(9.9,3)</codeph>,
            the type conversion for the second argument results in the first argument
            being interpreted as <codeph>DOUBLE</codeph>, so to produce an accurate
            <codeph>DECIMAL</codeph> result requires casting the second argument
            or writing it as a <codeph>DECIMAL</codeph> literal, 3.0.
          </p>
<codeblock>select mod(10,3);
+-------------+
| fmod(10, 3) |
+-------------+
| 1           |
+-------------+

select mod(5.5,2);
+--------------+
| fmod(5.5, 2) |
+--------------+
| 1.5          |
+--------------+

select 10 % 3;
+--------+
| 10 % 3 |
+--------+
| 1      |
+--------+

select 5.5 % 2;
+---------+
| 5.5 % 2 |
+---------+
| 1.5     |
+---------+

select mod(9.9,3.3);
+---------------+
| mod(9.9, 3.3) |
+---------------+
| 0.0           |
+---------------+

select mod(9.9,3);
+--------------------+
| mod(9.9, 3)        |
+--------------------+
| 0.8999996185302734 |
+--------------------+

select mod(9.9, cast(3 as decimal(2,1)));
+-----------------------------------+
| mod(9.9, cast(3 as decimal(2,1))) |
+-----------------------------------+
| 0.9                               |
+-----------------------------------+

select mod(9.9,3.0);
+---------------+
| mod(9.9, 3.0) |
+---------------+
| 0.9           |
+---------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry id="murmur_hash" rev="IMPALA-3651 2.12.0">

        <dt rev="2.12.0">
          <codeph>murmur_hash(type v)</codeph>
        </dt>

        <dd rev="2.12.0">
          <indexterm audience="hidden">murmur_hash() function</indexterm>
          <b>Purpose:</b> Returns a consistent 64-bit value derived from the input argument, for convenience of
          implementing <xref keyref="MurmurHash"> MurmurHash2</xref> non-cryptographic hash function.
          <p>
            <b>Return type:</b> <codeph>BIGINT</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            You might use the return value in an application where you perform load balancing, bucketing, or some
            other technique to divide processing or storage. This function provides a good performance for all kinds
            of keys such as number, ascii string and UTF-8. It can be recommended as general-purpose hashing function.
          </p>
          <p>
            Regarding comparison of murmur_hash with fnv_hash, murmur_hash is based on Murmur2 hash algorithm and fnv_hash
            function is based on FNV-1a hash algorithm. Murmur2 and FNV-1a can show very good randomness and performance
            compared with well known other hash algorithms, but Murmur2 slightly show better randomness and performance than FNV-1a.
            See <xref keyref="hash_functions1">[1]</xref><xref keyref="hash_functions2">[2]</xref><xref keyref="hash_functions1">[3]</xref> for details.
          </p>
          <p>
            Similar input values of different types could produce different hash values, for example the same
            numeric value represented as <codeph>SMALLINT</codeph> or <codeph>BIGINT</codeph>,
            <codeph>FLOAT</codeph> or <codeph>DOUBLE</codeph>, or <codeph>DECIMAL(5,2)</codeph> or
            <codeph>DECIMAL(20,5)</codeph>.
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
<codeblock>[localhost:21000] &gt; create table h (x int, s string);
[localhost:21000] &gt; insert into h values (0, 'hello'), (1,'world'), (1234567890,'antidisestablishmentarianism');
[localhost:21000] &gt; select x, murmur_hash(x) from h;
+------------+----------------------+
| x          | murmur_hash(x)       |
+------------+----------------------+
| 0          | 6960269033020761575  |
| 1          | -780611581681153783  |
| 1234567890 | -5754914572385924334 |
+------------+----------------------+
[localhost:21000] &gt; select s, murmur_hash(s) from h;
+------------------------------+----------------------+
| s                            | murmur_hash(s)       |
+------------------------------+----------------------+
| hello                        | 2191231550387646743  |
| world                        | 5568329560871645431  |
| antidisestablishmentarianism | -2261804666958489663 |
+------------------------------+----------------------+ </codeblock>
          <p>
            For short argument values, the high-order bits of the result have relatively higher entropy than fnv_hash:
          </p>
<codeblock>[localhost:21000] &gt; create table b (x boolean);
[localhost:21000] &gt; insert into b values (true), (true), (false), (false);
[localhost:21000] &gt; select x, murmur_hash(x) from b;
+-------+----------------------+
| x     | murmur_hash(x)       |
+-------+---------------------++
| true  | -5720937396023583481 |
| true  | -5720937396023583481 |
| false | 6351753276682545529  |
| false | 6351753276682545529  |
+-------+--------------------+-+</codeblock>
          <p>
            <b>Added in:</b> Impala 2.12.0
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="negative">

        <dt rev="2.0.1">
          <codeph>negative(numeric_type a)</codeph>
<!-- <codeph>negative(int a), negative(double a), negative(decimal(p,s) a)</codeph> -->
        </dt>

        <dd>
          <indexterm audience="hidden">negative() function</indexterm>
          <b>Purpose:</b> Returns the argument with the sign reversed; returns a positive value if the argument was
          already negative.
          <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/>
<!--
            <p>
              <b>Return type:</b> <codeph>int</codeph>, <codeph>double</codeph>,
              or <codeph>decimal(p,s)</codeph> depending on type of argument
            </p>
            -->
          <p>
            <b>Usage notes:</b> Use <codeph>-abs(a)</codeph> instead if you need to ensure all return values are
            negative.
          </p>
        </dd>

      </dlentry>

      <dlentry id="pi">

        <dt rev="1.4.0">
          <codeph>pi()</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">pi() function</indexterm>
          <b>Purpose:</b> Returns the constant pi.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="pmod">

        <dt>
          <codeph>pmod(bigint a, bigint b), pmod(double a, double b)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">pmod() function</indexterm>
          <b>Purpose:</b> Returns the positive modulus of a number.
          Primarily for <xref href="https://issues.apache.org/jira/browse/HIVE-656" scope="external" format="html">HiveQL compatibility</xref>.
          <p>
            <b>Return type:</b> <codeph>int</codeph> or <codeph>double</codeph>, depending on type of arguments
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show how the <codeph>fmod()</codeph> function sometimes returns a negative value
            depending on the sign of its arguments, and the <codeph>pmod()</codeph> function returns the same value
            as <codeph>fmod()</codeph>, but sometimes with the sign flipped.
          </p>
<codeblock>select fmod(-5,2);
+-------------+
| fmod(-5, 2) |
+-------------+
| -1          |
+-------------+

select pmod(-5,2);
+-------------+
| pmod(-5, 2) |
+-------------+
| 1           |
+-------------+

select fmod(-5,-2);
+--------------+
| fmod(-5, -2) |
+--------------+
| -1           |
+--------------+

select pmod(-5,-2);
+--------------+
| pmod(-5, -2) |
+--------------+
| -1           |
+--------------+

select fmod(5,-2);
+-------------+
| fmod(5, -2) |
+-------------+
| 1           |
+-------------+

select pmod(5,-2);
+-------------+
| pmod(5, -2) |
+-------------+
| -1          |
+-------------+
</codeblock>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="positive">

        <dt rev="2.0.1">
          <codeph>positive(numeric_type a)</codeph>
<!-- <codeph>positive(int a), positive(double a), positive(decimal(p,s) a</codeph> -->
        </dt>

        <dd>
          <indexterm audience="hidden">positive() function</indexterm>
          <b>Purpose:</b> Returns the original argument unchanged (even if the argument is negative).
          <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/>
<!--
            <p>
              <b>Return type:</b> <codeph>int</codeph>, <codeph>double</codeph>,
              or <codeph>decimal(p,s)</codeph> depending on type of argument
            </p>
            -->
          <p>
            <b>Usage notes:</b> Use <codeph>abs()</codeph> instead if you need to ensure all return values are
            positive.
          </p>
        </dd>

      </dlentry>

      <dlentry id="pow">

        <dt rev="1.4.0">
          <codeph>pow(double a, double p)</codeph>,
          <codeph id="power">power(double a, double p)</codeph>,
          <codeph rev="2.3.0" id="dpow">dpow(double a, double p)</codeph>,
          <codeph rev="2.3.0" id="fpow">fpow(double a, double p)</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">pow() function</indexterm>
          <indexterm audience="hidden">power() function</indexterm>
          <indexterm audience="hidden">dpow() function</indexterm>
          <indexterm audience="hidden">fpow() function</indexterm>
          <b>Purpose:</b> Returns the first argument raised to the power of the second argument.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry rev="1.4.0" id="precision">

        <dt rev="1.4.0">
          <codeph>precision(<varname>numeric_expression</varname>)</codeph>
        </dt>

        <dd rev="1.4.0">
          <indexterm audience="hidden">precision() function</indexterm>
          <b>Purpose:</b> Computes the precision (number of decimal digits) needed to represent the type of the
          argument expression as a <codeph>DECIMAL</codeph> value.
          <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
          <p>
            Typically used in combination with the <codeph>scale()</codeph> function, to determine the appropriate
            <codeph>DECIMAL(<varname>precision</varname>,<varname>scale</varname>)</codeph> type to declare in a
            <codeph>CREATE TABLE</codeph> statement or <codeph>CAST()</codeph> function.
          </p>
          <p>
            <b>Return type:</b> <codeph>int</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p conref="../shared/impala_common.xml#common/precision_scale_example"/>
        </dd>

      </dlentry>

      <dlentry id="quotient">

        <dt>
          <codeph>quotient(bigint numerator, bigint denominator)</codeph>,
          <codeph>quotient(double numerator, double denominator)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">quotient() function</indexterm>
          <b>Purpose:</b> Returns the first argument divided by the second argument, discarding any fractional
          part. Avoids promoting integer arguments to <codeph>DOUBLE</codeph> as happens with the <codeph>/</codeph> SQL
          operator. <ph rev="IMPALA-278">Also includes an overload that accepts <codeph>DOUBLE</codeph> arguments,
          discards the fractional part of each argument value before dividing, and again returns <codeph>BIGINT</codeph>.
          With integer arguments, this function works the same as the <codeph>DIV</codeph> operator.</ph>
          <p>
            <b>Return type:</b> <codeph>bigint</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="radians">

        <dt>
          <codeph>radians(double a)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">radians() function</indexterm>
          <b>Purpose:</b> Converts argument value from degrees to radians.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
        </dd>

      </dlentry>

      <dlentry id="rand">

        <dt>
          <codeph>rand()</codeph>, <codeph>rand(bigint seed)</codeph>,
          <codeph rev="2.3.0" id="random">random()</codeph>,
          <codeph rev="2.3.0">random(bigint seed)</codeph>
        </dt>

        <dd>
          <indexterm audience="hidden">rand() function</indexterm>
          <b>Purpose:</b> Returns a random value between 0 and 1. After <codeph>rand()</codeph> is called with a
          seed argument, it produces a consistent random sequence based on the seed value.
          <p>
            <b>Return type:</b> <codeph>double</codeph>
          </p>
          <p>
            <b>Usage notes:</b> Currently, the random sequence is reset after each query, and multiple calls to
            <codeph>rand()</codeph> within the same query return the same value each time. For different number
            sequences that are different for each query, pass a unique seed value to each call to
            <codeph>rand()</codeph>. For example, <codeph>select rand(unix_timestamp()) from ...</codeph>
          </p>
          <p conref="../shared/impala_common.xml#common/example_blurb"/>
          <p>
            The following examples show how <codeph>rand()</codeph> can produce sequences of varying predictability,
            so that you can reproduce query results involving random values or generate unique sequences of random
            values for each query.
            When <codeph>rand()</codeph> is called with no argument, it generates the same sequence of values each time,
            regardless of the ordering of the result set.
            When <codeph>rand()</codeph> is called with a constant integer, it generates a different sequence of values,
            but still always the same sequence for the same seed value.
            If you pass in a seed value that changes, such as the return value of the expression <codeph>unix_timestamp(now())</codeph>,
{'fraction_non_alphanumeric': 0.18265994260136292, 'fraction_numerical': 0.026384476385066906, 'mean_word_length': 1.9196234612599565, 'pattern_counts': {'":': 0, '<': 2313, '<?xml version=': 2, '>': 2313, 'https://': 10, 'lorem ipsum': 0, 'www.': 2, 'xml': 78}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 12, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '7042619', 'n_tokens_mistral': 27097, 'n_tokens_neox': 25297, 'n_words': 6654}