Julia Funciones matemáticas

Julia ofrece un conjunto de funciones matemáticas estándar eficientes y portátiles.

Comparación numérica

La siguiente tabla enumera las funciones utilizadas para la comparación numérica:

Función	Prueba si se cumple la siguiente propiedad
`isequal(x, y)`	`x`y`y`Si el valor y el tipo son exactamente iguales
`isfinite(x)`	`x`Si es un número finito
`isinf(x)`	`x`Si es infinito (positivo/negativo)
`isnan(x)`	`x`Si es`NaN`

isequal considera que los NaN son iguales entre sí:

Ejemplo

julia> isequal(NaN, NaN)
true

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

julia> isequal(NaN, NaN32)
true

isequal también se puede utilizar para distinguir ceros con signo:

Ejemplo

julia> -0.0 == 0.0
true

julia> isequal(-0.0, 0.0)
false

Ejemplos de otras funciones:

Ejemplo

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

Funciones de redondeo

La siguiente tabla enumera las funciones de redondeo compatibles con Julia:

Función	Descripción	Tipo de retorno
`round(x)`	`x`Redondea al entero más cercano	`typeof(x)`
`round(T, x)`	`x`Redondea al entero más cercano	`T`
`floor(x)`	`x`hacia`-Inf`Redondeo	`typeof(x)`
`floor(T, x)`	`x`hacia`-Inf`Redondeo	`T`
`ceil(x)`	`x`hacia`+Inf`Redondeo direccional	`typeof(x)`
`ceil(T, x)`	`x`hacia`+Inf`Redondeo direccional	`T`
`trunc(x)`	`x`Redondeo hacia cero	`typeof(x)`
`trunc(T, x)`	`x`Redondeo hacia cero	`T`

Ejemplo

julia> round(3.8)
4.0
julia> round(Int, 3.8)
4
julia> floor(3.8)
3.0
julia> floor(Int, 3.8)
3
julia> ceil(3.8)
4.0
julia> ceil(Int, 3.8)
4
julia> trunc(3.8)
3.0
julia> trunc(Int, 3.8)
3

Funciones de división

La siguiente tabla enumera las funciones de división compatibles con Julia:

Función	Descripción
`div(x,y)`, `x÷y`	División truncada: el resultado de dividir cualquier tipo de números omite la parte decimal y conserva la parte entera; el cociente se aproxima hacia cero.
`fld(x,y)`	División por redondeo hacia abajo; el cociente`-Inf`se aproxima
`cld(x,y)`	División por redondeo hacia arriba; el cociente`+Inf`se aproxima
`rem(x,y)`	Resto; satisface`x == div(x,y)*y + rem(x,y)`; el signo`x`coincide
`mod(x,y)`	Módulo; satisface`x == fld(x,y)*y + mod(x,y)`; el signo`y`coincide
`mod1(x,y)`	Con desplazamiento de 1`mod`; si`y>0`, entonces devuelve`r∈(0,y]`, si`y<0`, entonces`r∈[y,0)`y satisface`mod(r, y) == mod(x, y)`
`mod2pi(x)`	Módulo respecto a 2π;`0 <= mod2pi(x) < 2pi`
`divrem(x,y)`	devuelve`(div(x,y),rem(x,y))`
`fldmod(x,y)`	devuelve`(fld(x,y),mod(x,y))`
`gcd(x,y...)`	`x`, `y`el máximo común divisor de ,...
`lcm(x,y...)`	`x`, `y`el mínimo común múltiplo de ,...

Ejemplo

julia> div(11, 4)
2

julia> div(7, 4)
1

julia> fld(11, 4)
2

julia> fld(-5,3)
-2

julia> fld(7.5,3.3)
2.0

julia> cld(7.5,3.3)
3.0

julia> mod(5, 0:2)
2

julia> mod(3, 0:2)
0

julia> mod(8.9,2)
0.9000000000000004

julia> rem(8,4)
0

julia> rem(9,4)
1

julia> mod2pi(7*pi/5)
4.39822971502571

julia> divrem(8,3)
(2, 2)

julia> fldmod(12,4)
(3, 0)

julia> fldmod(13,4)
(3, 1)

julia> mod1(5,4)
1

julia> gcd(6,0)
6

julia> gcd(1//3,2//3)
1//3

julia> lcm(1//3,2//3)
2//3

Funciones de signo y valor absoluto

La siguiente tabla enumera las funciones de signo y valor absoluto compatibles con Julia:

Función	Descripción
`abs(x)`	`x`el módulo de
`abs2(x)`	`x`el cuadrado del módulo de
`sign(x)`	representa`x`el signo de, devuelve -1, 0 o +1
`signbit(x)`	indica si el bit de signo es true o false
`copysign(x,y)`	devuelve un número cuyo valor es igual al`x`módulo de, el signo`y`coincide
`flipsign(x,y)`	devuelve un número cuyo valor es igual al`x`módulo de, el signo`x*y`coincide

Ejemplo

julia> abs(-7)
7

julia> abs(5+3im)
5.830951894845301

julia> abs2(-7)
49

julia> abs2(5+3im)
34

julia> copysign(5,-10)
-5

julia> copysign(-5,10)
5

julia> sign(5)
1

julia> sign(-5)
-1

julia> signbit(-5)
true

julia> signbit(5)
false

julia> flipsign(5,10)
5

julia> flipsign(5,-10)
-5

Funciones de signo y valor absoluto

La siguiente tabla enumera las funciones de signo y valor absoluto compatibles con Julia:

Función	Descripción
`sqrt(x)`, `√x`	`x`la raíz cuadrada de
`cbrt(x)`, `∛x`	`x`la raíz cúbica de
`hypot(x,y)`	cuando la longitud de los catetos es`x`y`y`, la longitud de la hipotenusa del triángulo rectángulo
`exp(x)`	la función exponencial natural en`x`el valor en
`expm1(x)`	Cuando`x`cuando se aproxima a 0`exp(x)-1`el valor exacto de
`ldexp(x,n)`	`x*2^n`el algoritmo eficiente de,`n`es un entero
`log(x)`	`x`el logaritmo natural de
`log(b,x)`	con`b`con base`x`el logaritmo de
`log2(x)`	con base 2`x`el logaritmo de
`log10(x)`	con base 10`x`el logaritmo de
`log1p(x)`	Cuando`x`cuando se aproxima a 0`log(1+x)`el valor exacto de
`exponent(x)`	`x`el exponente binario de
`significand(x)`	número de punto flotante`x`el significando binario de (es decir, la mantisa)

Ejemplo

julia> sqrt(49)
7.0

julia> sqrt(-49)
ERROR: DomainError with -49.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) at .\math.jl:33
[2] sqrt at .\math.jl:573 [inlined]
[3] sqrt(::Int64) at .\math.jl:599
[4] top-level scope at REPL[43]:1

julia> cbrt(8)
2.0

julia> cbrt(-8)
-2.0

julia> a = Int64(5)^10;

julia> hypot(a, a)
1.3810679320049757e7

julia> exp(5.0)
148.4131591025766

julia> expm1(10)
22025.465794806718

julia> expm1(1.0)
1.718281828459045

julia> ldexp(4.0, 2)
16.0

julia> log(5,2)
0.43067655807339306

julia> log(4,2)
0.5

julia> log(4)
1.3862943611198906

julia> log2(4)
2.0

julia> log10(4)
0.6020599913279624

julia> log1p(4)
1.6094379124341003

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
[1] throw_complex_domainerror(::Symbol, ::Float64) at .\math.jl:33
[2] log1p(::Float64) at .\special\log.jl:356
[3] log1p(::Int64) at .\special\log.jl:395
[4] top-level scope at REPL[65]:1
julia> exponent(6.8)
2

julia> significand(15.2)/10.2
0.18627450980392157

julia> significand(15.2)*8
15.2

Funciones trigonométricas e hiperbólicas

Julia también proporciona todas las funciones trigonométricas e hiperbólicas estándar:

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

En la siguiente figura, un ángulo en radianes corresponde a un punto en el círculo unitario, cuyas coordenadas definen el seno y el coseno del ángulo.

Ejemplo

julia> pi
π = 3.1415926535897...

julia> sin(0)
0.0

julia> sin(pi/6)
0.49999999999999994

julia> sin(pi/4)
0.7071067811865475

julia> cos(0)
1.0

julia> cos(pi/6)
0.8660254037844387

julia> cos(pi/3)
0.5000000000000001

Las funciones proporcionadas anteriormente son todas de un solo parámetro, aunque atan también puede aceptar dos parámetros para representar la función tradicional atan2.

atan(y)
atan(y, x)

Calcula la arcotangente de y o de y/x, respectivamente.

Ejemplo

julia> theta = 3pi/4
2.356194490192345

julia> x,y = (cos(theta), sin(theta))
(-0.7071067811865475, 0.7071067811865476)

julia> atan(y/x)
-0.7853981633974484

julia> atan(y, x)
2.356194490192345

Además, sinpi(x) y cospi(x) se utilizan para calcular con mayor precisión sin(pi*x) y cos(pi*x), respectivamente.

Para calcular funciones trigonométricas con ángulos en grados en lugar de radianes, se utiliza el sufijo d. Por ejemplo, sind(x) calcula el seno de x, donde x es un valor en grados. A continuación se muestra la lista completa de funciones trigonométricas para ángulos:

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

Ejemplo

julia> cos(56)
0.853220107722584

julia> cosd(56)
0.5591929034707468

Otras extensiones