Spark SQL functions.scala 源码解析（五）Math Functions （基于 Spark 3.3.0）

前言

本文隶属于专栏《1000个问题搞定大数据技术体系》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！

本专栏目录结构和参考文献请见1000个问题搞定大数据技术体系

目录

Spark SQL functions.scala 源码解析（一）Sort functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（二）Aggregate functions（基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（三）Window functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（四）Non-aggregate functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（五）Math Functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（六）Misc functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（七）String functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（八）DateTime functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（九）Collection functions （基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（十）Partition transform functions（基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（十一）Scala UDF functions（基于 Spark 3.3.0）

Spark SQL functions.scala 源码解析（十二）Java UDF functions（基于 Spark 3.3.0）

正文

abs

  /**
   * 计算数值的绝对值。
   *
   * @group math_funcs
   * @since 1.3.0
   */
  def abs(e: Column): Column = withExpr { Abs(e.expr) }

acos/acosh

  /**
   * @return 以弧度表示的 e 的反余弦值，如同由java.lang.Math.acos计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def acos(e: Column): Column = withExpr { Acos(e.expr) }

  /**
   * @return columnName 的反余弦值，如同由java.lang.Math.acos计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def acos(columnName: String): Column = acos(Column(columnName))

  /**
   * @return e 的反双曲余弦
   *
   * @group math_funcs
   * @since 3.1.0
   */
  def acosh(e: Column): Column = withExpr { Acosh(e.expr) }

  /**
   * @return columnName 的反双曲余弦
   *
   * @group math_funcs
   * @since 3.1.0
   */
  def acosh(columnName: String): Column = acosh(Column(columnName))

asin/asinh

  /**
   * @return 以弧度表示的 e 的反正弦，如同由java.lang.Math.asin计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def asin(e: Column): Column = withExpr { Asin(e.expr) }

  /**
   * @return columnName 的反正弦，如同由java.lang.Math.asin计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def asin(columnName: String): Column = asin(Column(columnName))

  /**
   * @return e 的反双曲正弦
   *
   * @group math_funcs
   * @since 3.1.0
   */
  def asinh(e: Column): Column = withExpr { Asinh(e.expr) }

  /**
   * @return columnName 的反双曲正弦
   *
   * @group math_funcs
   * @since 3.1.0
   */
  def asinh(columnName: String): Column = asinh(Column(columnName))

atan/atan2/atanh

  /**
   * @return e 的反正切，如同由java.lang.Math.atan计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan(e: Column): Column = withExpr { Atan(e.expr) }

  /**
   * @return columnName 的反正切，如同由java.lang.Math.atan计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan(columnName: String): Column = atan(Column(columnName))

  /**
   * 参数：
   * y – y 轴坐标列
   * x – x 轴坐标列
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(y: Column, x: Column): Column = withExpr { Atan2(y.expr, x.expr) }

  /**
   * 参数：
   * y – y 轴坐标列
   * xName – x 轴坐标列名称
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(y: Column, xName: String): Column = atan2(y, Column(xName))

  /**
   * 参数：
   * yName – y 轴坐标列名称
   * x – x 轴坐标列
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(yName: String, x: Column): Column = atan2(Column(yName), x)

  /**
   * 参数：
   * yName – y 轴坐标列名称
   * xName – x 轴坐标列名称
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(yName: String, xName: String): Column =
    atan2(Column(yName), Column(xName))

  /**
   * 参数：
   * y – y 轴坐标列
   * xValue – x 轴坐标值
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(y: Column, xValue: Double): Column = atan2(y, lit(xValue))

  /**
   * 参数：
   * yName – y 轴坐标列名称
   * xValue – x 轴坐标值
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(yName: String, xValue: Double): Column = atan2(Column(yName), xValue)

  /**
   * 参数：
   * yValue – y 轴坐标值
   * x – x 轴坐标列
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(yValue: Double, x: Column): Column = atan2(lit(yValue), x)

  /**
   * 参数：
   * yValue – y 轴坐标值
   * xName – x 轴坐标列名称
   * 返回：
   * 对应于笛卡尔坐标中的点 ( x , y ) 的极坐标中点 ( r , theta ) 的 theta 分量，如同由
   * java.lang.Math.atan2计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def atan2(yValue: Double, xName: String): Column = atan2(yValue, Column(xName))

  /**
   * @return e 的反双曲正切值
   *
   * @group math_funcs
   * @since 3.1.0
   */
  def atanh(e: Column): Column = withExpr { Atanh(e.expr) }

  /**
   * @return columnName 的反双曲正切值
   *
   * @group math_funcs
   * @since 3.1.0
   */
  def atanh(columnName: String): Column = atanh(Column(columnName))

bin

  /**
   * 返回给定长列的二进制值的字符串表示形式的表达式。 
   * 例如，bin("12") 返回"1100"。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def bin(e: Column): Column = withExpr { Bin(e.expr) }

  /**
   * 返回给定长列的二进制值的字符串表示形式的表达式。 
   * 例如，bin("12") 返回"1100"。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def bin(columnName: String): Column = bin(Column(columnName))

cbrt

  /**
   * 计算给定值的立方根。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def cbrt(e: Column): Column = withExpr { Cbrt(e.expr) }

  /**
   *计算给定值的立方根。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def cbrt(columnName: String): Column = cbrt(Column(columnName))

ceil

  /**
   * 计算给定值的上限
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def ceil(e: Column): Column = withExpr { Ceil(e.expr) }

  /**
   * 计算给定值的上限
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def ceil(columnName: String): Column = ceil(Column(columnName))

conv

  /**
   * 将字符串列中的数字从一种基数转换为另一种基数
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def conv(num: Column, fromBase: Int, toBase: Int): Column = withExpr {
    Conv(num.expr, lit(fromBase).expr, lit(toBase).expr)
  }

cos/cosh

  /**
   * @param e 以弧度为单位的角度
   * @return 角度的余弦，如同由java.lang.Math.cos计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def cos(e: Column): Column = withExpr { Cos(e.expr) }

  /**
   * @param columnName 以弧度为单位的角度
   * @return 角度的余弦，如同由java.lang.Math.cos计算得到
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def cos(columnName: String): Column = cos(Column(columnName))

  /**
   * @param e 双曲角
   * @return 角度的双曲余弦值，如同由java.lang.Math.cosh计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def cosh(e: Column): Column = withExpr { Cosh(e.expr) }

  /**
   * @param columnName 双曲角
   * @return 角度的双曲余弦值，如同由java.lang.Math.cosh计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def cosh(columnName: String): Column = cosh(Column(columnName))

cot

  /**
   * @param e 以弧度为单位的角度
   * @return 角的余切
   *
   * @group math_funcs
   * @since 3.3.0
   */
  def cot(e: Column): Column = withExpr { Cot(e.expr) }

csc

  /**
   * @param e 以弧度为单位的角度
   * @return 角的余割
   *
   * @group math_funcs
   * @since 3.3.0
   */
  def csc(e: Column): Column = withExpr { Csc(e.expr) }

exp/expm1

  /**
   * 计算给定列的指数
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def exp(e: Column): Column = withExpr { Exp(e.expr) }

  /**
   * 计算给定列的指数
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def exp(columnName: String): Column = exp(Column(columnName))

  /**
   * 计算给定列的指数减一。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def expm1(e: Column): Column = withExpr { Expm1(e.expr) }

  /**
   * 计算给定列的指数减一。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def expm1(columnName: String): Column = expm1(Column(columnName))

factorial

  /**
   * 计算给定列的阶乘。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def factorial(e: Column): Column = withExpr { Factorial(e.expr) }

floor

  /**
   * 计算给定列的下限。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def floor(e: Column): Column = withExpr { Floor(e.expr) }

  /**
   * 计算给定列的下限。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def floor(columnName: String): Column = floor(Column(columnName))

hex/unhex

  /**
   * 计算给定列的十六进制值。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def hex(column: Column): Column = withExpr { Hex(column.expr) }

  /**
   * 十六进制的倒数。 
   * 将每对字符解释为一个十六进制数并转换为数字的字节表示。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def unhex(column: Column): Column = withExpr { Unhex(column.expr) }

hypot

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(l: Column, r: Column): Column = withExpr { Hypot(l.expr, r.expr) }

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(l: Column, rightName: String): Column = hypot(l, Column(rightName))

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(leftName: String, r: Column): Column = hypot(Column(leftName), r)

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(leftName: String, rightName: String): Column =
    hypot(Column(leftName), Column(rightName))

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(l: Column, r: Double): Column = hypot(l, lit(r))

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(leftName: String, r: Double): Column = hypot(Column(leftName), r)

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(l: Double, r: Column): Column = hypot(lit(l), r)

  /**
   * 计算 `sqrt(a^2^ + b^2^)` 没有中间溢出或下溢。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def hypot(l: Double, rightName: String): Column = hypot(l, Column(rightName))

log/log10/log1p/log2

  /**
   * 计算给定值的自然对数。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log(e: Column): Column = withExpr { Log(e.expr) }

  /**
   * 计算给定值的自然对数。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log(columnName: String): Column = log(Column(columnName))

  /**
   * 返回第一个参数为底的第二个参数的对数。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log(base: Double, a: Column): Column = withExpr { Logarithm(lit(base).expr, a.expr) }

  /**
    * 返回第一个参数为底的第二个参数的对数。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log(base: Double, columnName: String): Column = log(base, Column(columnName))

  /**
   * 计算以 10 为底的给定值的对数
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log10(e: Column): Column = withExpr { Log10(e.expr) }

  /**
   * 计算以 10 为底的给定值的对数
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log10(columnName: String): Column = log10(Column(columnName))

  /**
   * 计算给定值加一的自然对数。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log1p(e: Column): Column = withExpr { Log1p(e.expr) }

  /**
   * 计算给定值加一的自然对数。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def log1p(columnName: String): Column = log1p(Column(columnName))

  /**
   * 计算给定列的以 2 为底的对数。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def log2(expr: Column): Column = withExpr { Log2(expr.expr) }

  /**
   * 计算给定列的以 2 为底的对数。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def log2(columnName: String): Column = log2(Column(columnName))

pow

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(l: Column, r: Column): Column = withExpr { Pow(l.expr, r.expr) }

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(l: Column, rightName: String): Column = pow(l, Column(rightName))

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(leftName: String, r: Column): Column = pow(Column(leftName), r)

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(leftName: String, rightName: String): Column = pow(Column(leftName), Column(rightName))

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(l: Column, r: Double): Column = pow(l, lit(r))

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(leftName: String, r: Double): Column = pow(Column(leftName), r)

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(l: Double, r: Column): Column = pow(lit(l), r)

  /**
   * 返回第一个参数的幂为第二个参数的值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def pow(l: Double, rightName: String): Column = pow(l, Column(rightName))

pmod

  /**
   * 返回被除数 mod 除数的正值。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def pmod(dividend: Column, divisor: Column): Column = withExpr {
    Pmod(dividend.expr, divisor.expr)
  }

rint

  /**
   * 返回值与参数最接近且等于数学整数的双精度值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def rint(e: Column): Column = withExpr { Rint(e.expr) }

  /**
   * 返回值与参数最接近且等于数学整数的双精度值。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def rint(columnName: String): Column = rint(Column(columnName))

round

  /**
   * 返回使用 HALF_UP 舍入模式舍入到 0 位小数的列e的值。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def round(e: Column): Column = round(e, 0)

  /**
   * 如果scale大于或等于 0 或在scale小于 0 时为整数部分，则使用 HALF_UP 舍入模式将e的值四舍五入
   * 以缩放小数位。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  def round(e: Column, scale: Int): Column = withExpr { Round(e.expr, Literal(scale)) }

HALF_UP 舍入模式：向最接近的数字方向舍入，如果与两个相邻数字的距离相等，则正数向大，负数向小。

bround

  /**
   * 返回使用 HALF_EVEN 舍入模式舍入到 0 位小数的列e的值。
   *
   * @group math_funcs
   * @since 2.0.0
   */
  def bround(e: Column): Column = bround(e, 0)

  /**
   * 如果scale大于或等于 0 或在scale小于 0 时为整数部分，则将e的值四舍五入以使用 HALF_EVEN 舍入
   * 模式缩放小数位。
   *
   * @group math_funcs
   * @since 2.0.0
   */
  def bround(e: Column, scale: Int): Column = withExpr { BRound(e.expr, Literal(scale)) }

HALF_EVEN 舍入模式：向最接近数字方向舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。

sec

  /**
   * @param e 以弧度表示的角度
   * @return 角的正割
   *
   * @group math_funcs
   * @since 3.3.0
   */
  def sec(e: Column): Column = withExpr { Sec(e.expr) }

shiftleft/shiftright/shiftrightunsigned

  /**
   * 将给定值 numBits 左移。 
   * 如果给定的值为 long 值，则此函数将返回一个 long 值，否则将返回一个 integer 值。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  @deprecated("Use shiftleft", "3.2.0")
  def shiftLeft(e: Column, numBits: Int): Column = shiftleft(e, numBits)

  /**
   * 将给定值 numBits 左移。 
   * 如果给定的值为 long 值，则此函数将返回一个 long 值，否则将返回一个 integer 值。
   *
   * @group math_funcs
   * @since 3.2.0
   */
  def shiftleft(e: Column, numBits: Int): Column = withExpr { ShiftLeft(e.expr, lit(numBits).expr) }

  /**
   * （有符号）将给定值 numBits 右移。 
   * 如果给定的值为 long 值，则此函数将返回一个 long 值，否则将返回一个 integer 值。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  @deprecated("Use shiftright", "3.2.0")
  def shiftRight(e: Column, numBits: Int): Column = shiftright(e, numBits)

  /**
   * （有符号）将给定值 numBits 右移。 
   * 如果给定的值为 long 值，则此函数将返回一个 long 值，否则将返回一个 integer 值。
   *
   * @group math_funcs
   * @since 3.2.0
   */
  def shiftright(e: Column, numBits: Int): Column = withExpr {
    ShiftRight(e.expr, lit(numBits).expr)
  }

  /**
   * （无符号）将给定值 numBits 右移。 
   * 如果给定的值为 long 值，则此函数将返回一个 long 值，否则将返回一个 integer 值。
   *
   * @group math_funcs
   * @since 1.5.0
   */
  @deprecated("Use shiftrightunsigned", "3.2.0")
  def shiftRightUnsigned(e: Column, numBits: Int): Column = shiftrightunsigned(e, numBits)

  /**
   * （无符号）将给定值 numBits 右移。 
   * 如果给定的值为 long 值，则此函数将返回一个 long 值，否则将返回一个 integer 值。
   *
   * @group math_funcs
   * @since 3.2.0
   */
  def shiftrightunsigned(e: Column, numBits: Int): Column = withExpr {
    ShiftRightUnsigned(e.expr, lit(numBits).expr)
  }

signum

  /**
   * 计算给定值的符号。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def signum(e: Column): Column = withExpr { Signum(e.expr) }

  /**
   * 计算给定值的符号。
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def signum(columnName: String): Column = signum(Column(columnName))

sin/sinh

  /**
   * @param e 以弧度表示的角度
   * @return 角度的正弦值，如同由java.lang.Math.sin计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def sin(e: Column): Column = withExpr { Sin(e.expr) }

  /**
   * @param e 以弧度表示的角度
   * @return 角度的正弦值，如同由java.lang.Math.sin计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def sin(columnName: String): Column = sin(Column(columnName))

  /**
   * @param e 双曲角
   * @return 给定值的双曲正弦值，如同由java.lang.Math.sinh计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def sinh(e: Column): Column = withExpr { Sinh(e.expr) }

  /**
   * @param columnName 双曲角
   * @return 给定值的双曲正弦值，如同由java.lang.Math.sinh计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def sinh(columnName: String): Column = sinh(Column(columnName))

tan/tanh

  /**
   * @param e 以弧度表示的角度
   * @return 给定值的正切，如同由java.lang.Math.tan计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def tan(e: Column): Column = withExpr { Tan(e.expr) }

  /**
   * @param e 以弧度表示的角度
   * @return 给定值的正切，如同由java.lang.Math.tan计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def tan(columnName: String): Column = tan(Column(columnName))

  /**
   * @param e 双曲角
   * @return 给定值的双曲正切值，如同由java.lang.Math.tanh计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def tanh(e: Column): Column = withExpr { Tanh(e.expr) }

  /**
   * @param columnName 双曲角
   * @return 给定值的双曲正切值，如同由java.lang.Math.tanh计算
   *
   * @group math_funcs
   * @since 1.4.0
   */
  def tanh(columnName: String): Column = tanh(Column(columnName))

degrees

  /**
   * @group math_funcs
   * @since 1.4.0
   */
  @deprecated("Use degrees", "2.1.0")
  def toDegrees(e: Column): Column = degrees(e)

  /**
   * @group math_funcs
   * @since 1.4.0
   */
  @deprecated("Use degrees", "2.1.0")
  def toDegrees(columnName: String): Column = degrees(Column(columnName))
  
  /**
   * 将以弧度为单位的角度转换为以度为单位的近似等效的角度
   *
   * @param e 以弧度表示的角度
   * @return 以度为单位的角度，如同由java.lang.Math.toDegrees计算
   *
   * @group math_funcs
   * @since 2.1.0
   */
  def degrees(e: Column): Column = withExpr { ToDegrees(e.expr) }

  /**
   * 将以弧度为单位的角度转换为以度为单位的近似等效的角度
   *
   * @param columnName 以弧度表示的角度
   * @return 以度为单位的角度，如同由java.lang.Math.toDegrees计算
   *
   * @group math_funcs
   * @since 2.1.0
   */
  def degrees(columnName: String): Column = degrees(Column(columnName))

radians

  /**
   * @group math_funcs
   * @since 1.4.0
   */
  @deprecated("Use radians", "2.1.0")
  def toRadians(e: Column): Column = radians(e)

  /**
   * @group math_funcs
   * @since 1.4.0
   */
  @deprecated("Use radians", "2.1.0")
  def toRadians(columnName: String): Column = radians(Column(columnName))

  /**
   * 将以度为单位的角度转换为以弧度为单位的近似等效的角度。
   * @param e 以度表示的角度
   * @return 以弧度为单位的角度，如同由java.lang.Math.toRadians计算
   *
   * @group math_funcs
   * @since 2.1.0
   */
  def radians(e: Column): Column = withExpr { ToRadians(e.expr) }

  /**
   * 将以度为单位的角度转换为以弧度为单位的近似等效的角度。
   * @param columnName 以度表示的角度
   * @return 以弧度为单位的角度，如同由java.lang.Math.toRadians计算
   *
   * @group math_funcs
   * @since 2.1.0
   */
  def radians(columnName: String): Column = radians(Column(columnName))