Julia1.4文档 —— 3. Julia 数学运算和基本函数

Julia 为它所有的基础数值类型，提供了整套的基础算术和位运算，也提供了一套高效、可移植的标准数学函数。

算术运算符

下面的算术运算符适用于所有的基本数值类型：

表达式	名称	描述
+x	一元加法 x	本身
-x	一元减法	相反数
x + y	二元加法	做加法
x - y	二元减法	做减法
x * y	乘法	做乘法
x / y	除法	做除法
x \ y	反除	等价于 y / x
x ^ y	乘方	x 的 y 次幂
x % y	取余	等价于 rem(x, y)

以及 Bool 类型的非运算：

表达式	名称	描述
!x	非	true 和 false 互换

Julia 的类型提升系统使得参数类型混杂的算术运算也很简单自然。详见类型转换和类型提升 。

算术运算的例子：

julia> 1 + 2 + 3
6

julia> 1 - 2
-1

julia> 3*2/12
0.5

（习惯上，优先级低的运算，前后多补些空格。这不是强制的。）

位运算符

下面的位运算符适用于所有整数类型：

表达式	名称
~x	按位取反
x & y	按位与
x | y	按位或
x ⊻ y	按位异或
x >>> y	向右 逻辑移位 （高位补 0 ）
x >> y	向右 算术移位 （复制原高位）
x << y	向左逻辑/算术移位

位运算的例子：

julia> ~123
-124

julia> 123 & 234
106

julia> 123 | 234
251

julia> 123 ⊻ 234
145

julia> xor(123, 234)
145

julia> ~UInt32(123)
0xffffff84

julia> ~UInt8(123)
0x84

复合赋值运算符

二元算术和位运算都有对应的复合赋值运算符，即运算的结果将会被赋值给左操作数。在操作符的后面直接加上 = 就组成了复合赋值运算符。例如, x += 3相当于 x = x + 3 ：

julia>  x = 1
1

julia> x += 3
4

julia> x
4

复合赋值运算符有：

+=  -=  *=  /=  \=  ÷=  %=  ^=  &=  |=  ⊻=  >>>=  >>=  <<=

按元素操作符

针对数组、矩阵，相应的纯量操作符会被施加到每一 个元素上去

#相应的纯量操作符会被施加到每一 个元素上去
.+  .-  .*  .^ .<

julia> [1,2,3] .^ 3
3-element Array{Int64,1}:
  1
  8
 27
 
#等价于[1^3, 2^3, 3^3]
julia> [1^3, 2^3, 3^3]
3-element Array{Int64,1}:
  1
  8
 27

数值比较

所有的基础数值类型都可以使用比较运算符：

运算符	名称
==	等于
!=, ≠	不等于
<	小于
<=, ≤	小于等于
>	大于
>=, ≥	大于等于

一些例子：

julia> 1 == 1
true

julia> 1 == 2
false

julia> 1 != 2
true

julia> 1 == 1.0
true

julia> 1 < 2
true

julia> 1.0 > 3
false

julia> 1 >= 1.0
true

julia> -1 <= 1
true

julia> -1 <= -1
true

julia> -1 <= -2
false

julia> 3 < -0.5
false

整数是按位比较的。浮点数是 IEEE 754 标准 比较的：

• 有限数按照正常方式做比较。
• 正数的零等于但不大于负数的零。
• Inf 等于它本身，并且大于所有数, 除了 NaN。
• -Inf 等于它本身，并且小于所有数, 除了 NaN。
• NaN 不等于、不大于、不小于任何数，包括它本身。

上面最后一条是关于 NaN 的性质，值得留意：

julia> NaN == NaN
false

julia> NaN != NaN
true

julia> NaN < NaN
false

julia> NaN > NaN
false

NaN 在矩阵中使用时会带来些麻烦：

julia> [1 NaN] == [1 NaN]
false

Julia 提供了附加函数, 用以测试这些特殊值，它们使用哈希值来比较：

函数	测试
isequal(x, y)	x 是否等价于 y
isfinite(x)	x是否为有限的数
isinf(x) x	是否为无限的数
isnan(x)	x 是否不是数

isequal函数，认为NaN 等于它本身：

julia> isequal(NaN, NaN)
true

julia> isequal([1 NaN],[1 NaN])
true

julia> isequal(NaN, NaN32)
true

isequal 也可以用来区分有符号的零：

julia> isequal(-0.0, 0.0)
false

julia> -0.0 == 0.0
true

链式比较

与大多数语言不同，Julia 支持 Python 链式比较 ：

julia> 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
true

对标量的比较，链式比较使用 && 运算符；对逐元素的比较使用 & 运算符，此运算符也可用于数组。例如， 0 .< A .< 1 的结果是一个对应的布尔数组，满足条件的元素返回 true 。

Elementary Functions
Julia provides a comprehensive collection of mathematical functions and operators. These mathematical operations are defined over as broad a class of numerical values as permit sensible definitions, including integers, floating-point numbers, rationals, and complex numbers, wherever such definitions make sense.
Moreover, these functions (like any Julia function) can be applied in “vectorized” fashion to arrays and other collections with the dot syntax f.(A), e.g. sin.(A) will compute the sine of each element of an array A.

注意链式比较的比较顺序：

julia> v(x) = (println(x); x)
v (generic function with 1 method)

julia> v(1) < v(2) <= v(3)
2
1
3
true

julia> v(1) > v(2) <= v(3)
2
1
false

中间的值只计算了一次，而不是像 v(1) < v(2) && v(2) <= v(3) 一样计算了两次。但是，链式比较的计算顺序是不确定的。不要在链式比较中使用带副作用（比如打印）的表达式。如果需要使用副作用表达式，推荐使用短路 && 运算符（详见短路求值）。

运算优先级

Julia 运算优先级从高至低依次为：

类型	运算符	Associativity
语法	. 跟随 ::	左
幂	^ 和 .^ 等效	右
一元	+ - √	右
位移	<< >> >>> 和 .<< .>> .>>>	左
分数	// 和 .//	左
乘除	/ % & \和 .* ./ .% .\	左
加减	+ - | ⊻ 和 .+ .-	左
语法	: ..	左
语法	|>	左
语法	<|	右
比较	> < >= <= == === != !== <:和 .> .< .>= .<= .== .!=	非关联
逻辑	&& 跟随于|| 跟随于 ?	右
Pair	=>	右
赋值	= += -= *= /= //= \= ^= ÷= %= |= &= ⊻= <<= >>= >>>=及.+= .-= .*= ./= .//= .\= .^= .%=	右

详细了解

数值表达式，例如2x，被视为比任何其他二进制运算具有更高优先级的乘法，并且也具有比^更高的优先级。

可以通过内置函数Base.operator_precedence，来获取运算符的优先级：

julia> Base.operator_precedence(:+), Base.operator_precedence(:*), Base.operator_precedence(:.)
(11, 12, 17)

julia> Base.operator_precedence(:sin), Base.operator_precedence(:+=), Base.operator_precedence(:(=))  # (Note the necessary parens on `:(=)`)
(0, 1, 1)

还可以通过调用内置函数Base.operator_associativity:得到运算符的Associativity：

julia> Base.operator_associativity(:-), Base.operator_associativity(:+), Base.operator_associativity(:^)
(:left, :none, :right)

julia> Base.operator_associativity(:⊗), Base.operator_associativity(:sin), Base.operator_associativity(:→)
(:left, :none, :right)

注意：:sin 返回的值为 0，此值表示无效的运算符，而不是优先级最低的运算符，同理，这样的运算符的Associativity为 :none

数值转换

Julia支持三种形式的数值转换，它们对转换异常的处理不同。

• T(x) or convert(T,x)：将x转换为T类型的值
  • 如果T是浮点型，结果是最接近的可表示值，可以是正无穷大，也可以是负无穷大。
  • 如果T是整型，如果x不能转换为T类型，则会抛出InexactError
• x % T：将整数x转换为整数类型T的值，该值与x的模2^n相同，其中n是T中的位数。换句话说，二进制的表示会被截断。如128 % Int8的结果为-128。
• Rounding functions：将x转换为T类型的值，例如round(Int,x) 是 Int(round(x))的简写

一些例子：

julia> Int8(127)
127

julia> Int8(128)
ERROR: InexactError: trunc(Int8, 128)
Stacktrace:
 [1] throw_inexacterror(::Symbol, ::Type{Int8}, ::Int64) at ./boot.jl:557
 [2] checked_trunc_sint at ./boot.jl:579 [inlined]
 [3] toInt8 at ./boot.jl:594 [inlined]
 [4] Int8(::Int64) at ./boot.jl:704
 [5] top-level scope at REPL[188]:1

julia> Int8(127.0)
127

julia> Int8(3.14)
ERROR: InexactError: Int8(3.14)
Stacktrace:
 [1] Int8(::Float64) at ./float.jl:689
 [2] top-level scope at REPL[190]:1

julia> Int8(128.0)
ERROR: InexactError: Int8(128.0)
Stacktrace:
 [1] Int8(::Float64) at ./float.jl:689
 [2] top-level scope at REPL[191]:1

julia> 127 % Int8
127

julia> 128 % Int8
-128

julia> round(Int8, 127.4)
127

julia> round(Int8, 127.6)
ERROR: InexactError: trunc(Int8, 128.0)
Stacktrace:
 [1] trunc at ./float.jl:682 [inlined]
 [2] round(::Type{Int8}, ::Float64) at ./float.jl:367
 [3] top-level scope at REPL[195]:1

基本函数

舍入函数

函数	描述	返回类型
round(x)	把 x 舍入到最近的整数	FloatingPoint
iround(x)	把 x 舍入到最近的整数	Integer
floor(x)	把 x 向 -Inf 取整	FloatingPoint
ifloor(x)	把 x 向 -Inf取整	Integer
ceil(x)	把 x 向 +Inf 取整	FloatingPoint
iceil(x)	把 x 向 +Inf 取整	Integer
trunc(x)	把 x 向 0取整	FloatingPoint
itrunc(x)	把 x 向 0 取整	Integer

除法函数

函数	描述
div(x,y)	截断取整除法；商向 0 舍入；等价于(x÷y)
fld(x,y)	向下取整除法；商向 -Inf舍入
cld(x,y)	向上取整除法; 商向 +Inf 舍入
rem(x,y)	除法余数；满足 x == div(x,y)*y + rem(x,y) ，与 x同号
mod(x,y)	取模余数；满足 x == fld(x,y)*y + mod(x,y)，与 y 同号
mod1(x,y)	偏移1位取模; 与 y 同号, mod(r, y) == mod(x, y)
mod2pi(x)	对 2pi 取模余数； 0 <= mod2pi(x) < 2pi
divrem(x,y)	返回 (div(x,y),rem(x,y))
fldmod(x,y)	返回 (fld(x,y),mod(x,y))
gcd(x,y...)	x, y, ... 的最大公约数，与 x同号
lcm(x,y...)	x, y, ... 的最小公倍数，与 x同号

julia> mod1(1.6, 1)
0.6000000000000001

julia> mod1(1.6, -1)
-0.3999999999999999

julia> mod1(-0.3999999999999999, -1)
-0.3999999999999999

符号函数和绝对值函数

函数	描述
abs(x)	x的幅值
abs2(x)	x 的幅值的平方
sign(x)	x 的正负号，返回值为 -1, 0, 或 +1
signbit(x)	是否有符号位，有 (true) 或者 无 (false)
copysign(x,y)	返回一个数，它具有 x 的幅值， y 的符号位
flipsign(x,y)	返回一个数，它具有 x 的幅值， x*y 的符号位

乘方，对数和开方

函数	描述
sqrt(x),√x	x 的平方根
cbrt(x), ∛x	x 的立方根
hypot(x,y)	误差较小的sqrt(x^2 + y^2)
exp(x)	自然指数 e 的 x 次幂
expm1(x)	当 x 接近 0 时，精确计算 exp(x)-1
ldexp(x,n)	当 n 为整数时，高效计算x*2^n
log(x)	x 的自然对数
log(b,x)	以 b 为底 x的对数
log2(x)	以 2 为底 x 的对数
log10(x)	以 10 为底 x 的对数
log1p(x)	当 x 接近 0 时，精确计算 log(1+x)
exponent(x)	trunc(log2(x))，binary exponent of x
significand(x)	returns the binary significand (a.k.a. mantissa) of a floating-point number x

为什么要有 hypot, expm1, log1p 等函数，参见 John D. Cook 的博客： expm1, log1p, erfc 和 hypot 。

三角函数和双曲函数

Julia 内置了所有的标准三角函数和双曲函数

sin    cos    tan    cot    sec    csc
sinh   cosh   tanh   coth   sech   csch
asin   acos   atan   acot   asec   acsc
asinh  acosh  atanh  acoth  asech  acsch
sinc   cosc

除了 atan2 之外，都是单参数函数。atan2 给出了 x 轴，与由 x 、 y 确定的点之间的弧度 。

另外，sinpi(x)和 cospi(x)各自被提供给更准确的 sin(pi*x)和 cos(pi*x)的计算。

如果想要以度，而非弧度，为单位计算三角函数，应使用带 d 后缀的函数。例如，sind(x) 计算 x 的正弦值，这里 x 的单位是度。以下的列表是全部的以度为单位的三角函数：

sind   cosd   tand   cotd   secd   cscd
asind  acosd  atand  acotd  asecd  acscd

特殊函数

函数	描述
erf(x)	x 处的误差函数
erfc(x)	补误差函数。当 x 较大时，精确计算 1-erf(x)
erfinv(x)	erf 的反函数
erfcinv(x)	erfc 的反函数
erfi(x)	将误差函数定义为 -im erf(x im) ，其中im 是虚数单位
erfcx(x)	缩放的互补误差函数，即对较大的 x 值的准确的 exp（x ^ 2）* erfc（x）
dawson(x)	缩放虚误差函数，又名道森函数，即对较大的 x 值求精确的 exp(-x^2) erfi(x) sqrt(pi) / 2
gamma(x)	x 处的 gamma 函数
lgamma(x)	当x 较大时，精确计算 log(gamma(x))
lfact(x)	对较大的 x求精确的 log(factorial(x)); 与对大于 1 的 x 值求lgamma(x+1) 相等, 否则等于 0
digamma(x)	x处的 digamma 函数，即导数的衍生
beta(x,y)	在（x,y）处的 beta 函数
lbeta(x,y)	对较大的 x 或 y 值求准确的 log(beta(x,y))
eta(x)	x 处的 Dirichlet eta函数
zeta(x)	x处的 Riemann zeta 函数
airy(z), airyai(z), airy(0,z)	z 处的 Airy Ai函数
airyprime(z), airyaiprime(z), airy(1,z)	Airy Ai 函数在 z处的导数
airybi(z), airy(2,z)	z处的 Airy Bi 函数
airybiprime(z), airy(3,z)	Airy Bi函数在 z 处的导数
airyx(z), airyx(k,z)	缩放 Airy Ai 函数 以及 k 对z的导数
besselj(nu,z)	对 z 中一阶nu 的贝塞尔函数
besselj0(z)	besselj(0,z)
besselj1(z)	besselj(1,z)
besseljx(nu,z)	对 z 中一阶 nu的缩放贝塞尔函数
bessely(nu,z)	对 z 中二阶 nu的贝塞尔函数
bessely0(z)	bessely(0,z)
bessely1(z)	bessely(1,z)
besselyx(nu,z)	对 z 中二阶 nu 的缩放贝塞尔函数
besselh(nu,k,z)	对 z中三阶 nu （例如汉克尔函数）的贝塞尔函数； k 必须为 1 或 2
hankelh1(nu,z)	besselh(nu, 1, z)
hankelh1x(nu,z)	缩放 besselh(nu, 1, z)
hankelh2(nu,z)	besselh(nu, 2, z)
hankelh2x(nu,z)	缩放 besselh(nu, 2, z)
besseli(nu,z)	对 z 中一阶 nu 的修正贝塞尔函数
besselix(nu,z)	对 z 中一阶 nu 的缩放修正贝塞尔函数
besselk(nu,z)	对 z 中二阶 nu 的修正贝塞尔函数
besselkx(nu,z)	对二阶 o的缩放修正贝塞尔函数