Mathematics

-(x)

Operador unario menos.

Véase también: abs, flipsign.

Ejemplos

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{Int64}:
 -1  -2
 -3  -4

julia> -(true)  # se promueve a Int
-1

julia> -(0x003)
0xfffd

dt::Date + t::Time -> DateTime

La adición de un Date con un Time produce un DateTime. Las partes de hora, minuto, segundo y milisegundo del Time se utilizan junto con el año, mes y día del Date para crear el nuevo DateTime. Los microsegundos o nanosegundos no cero en el tipo Time resultarán en que se lance un InexactError.

+(x, y...)

Operador de adición.

La infija x+y+z+... llama a esta función con todos los argumentos, es decir, +(x, y, z, ...), que por defecto luego llama a (x+y) + z + ... comenzando desde la izquierda.

Ten en cuenta que el desbordamiento es posible para la mayoría de los tipos de enteros, incluido el Int por defecto, al sumar números grandes.

Ejemplos

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

julia> [1,2] + [3,4]
2-element Vector{Int64}:
 4
 6

julia> typemax(Int) + 1 < 0
true

-(x, y)

Operador de resta.

Ejemplos

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

Operador de multiplicación.

La infija x*y*z*... llama a esta función con todos los argumentos, es decir, *(x, y, z, ...), que por defecto luego llama a (x*y) * z * ... comenzando desde la izquierda.

La yuxtaposición como 2pi también llama a *(2, pi). Tenga en cuenta que esta operación tiene una precedencia más alta que un literal *. También note que la yuxtaposición "0x..." (cero entero veces una variable cuyo nombre comienza con x) está prohibida ya que choca con los literales de enteros sin signo: 0x01 isa UInt8.

Tenga en cuenta que el desbordamiento es posible para la mayoría de los tipos de enteros, incluido el Int por defecto, al multiplicar números grandes.

Ejemplos

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # matriz * vector
Vector de 2 elementos{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # la yuxtaposición tiene mayor precedencia
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # vector adjunto * vector
5

/(x, y)

Operador de división a la derecha: multiplicación de x por el inverso de y a la derecha.

Devuelve resultados de punto flotante para argumentos enteros. Consulta ÷ para división entera, o // para resultados de Rational.

Ejemplos

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

División a la derecha de matrices: A / B es equivalente a (B' \ A')' donde \ es el operador de división a la izquierda. Para matrices cuadradas, el resultado X es tal que A == X*B.

Véase también: rdiv!.

Ejemplos

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

\(x, y)

Operador de división izquierda: multiplicación de y por la inversa de x a la izquierda. Devuelve resultados de punto flotante para argumentos enteros.

Ejemplos

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [4 3; 2 1]; x = [5, 6];

julia> A \ x
2-element Vector{Float64}:
  6.5
 -7.0

julia> inv(A) * x
2-element Vector{Float64}:
  6.5
 -7.0

^(x, y)

Operador de exponenciación.

Si x e y son enteros, el resultado puede desbordarse. Para ingresar números en notación científica, utiliza literales de Float64 como 1.2e3 en lugar de 1.2 * 10^3.

Si y es un literal Int (por ejemplo, 2 en x^2 o -3 en x^-3), el código de Julia x^y es transformado por el compilador a Base.literal_pow(^, x, Val(y)), para permitir la especialización en tiempo de compilación sobre el valor del exponente. (Como una opción de respaldo por defecto, tenemos Base.literal_pow(^, x, Val(y)) = ^(x,y), donde generalmente ^ == Base.^ a menos que ^ haya sido definido en el espacio de nombres que llama.) Si y es un literal entero negativo, entonces Base.literal_pow transforma la operación a inv(x)^-y por defecto, donde -y es positivo.

Ver también exp2, <<.

Ejemplos

julia> 3^5
243

julia> 3^-1  # utiliza Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # desbordamiento entero
false

julia> big(10)^19 == 1e19
true

fma(x, y, z)

Calcula x*y+z sin redondear el resultado intermedio x*y. En algunos sistemas, esto es significativamente más costoso que x*y+z. fma se utiliza para mejorar la precisión en ciertos algoritmos. Consulta muladd.

muladd(x, y, z)

Multiplicación-suma combinada: calcula x*y+z, pero permite que la suma y la multiplicación se fusionen entre sí o con operaciones circundantes para mejorar el rendimiento. Por ejemplo, esto puede implementarse como un fma si el hardware lo admite de manera eficiente. El resultado puede ser diferente en diferentes máquinas y también puede ser diferente en la misma máquina debido a la propagación de constantes u otras optimizaciones. Ver fma.

Ejemplos

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

Multiplicación-suma combinada, A*y .+ z, para multiplicación de matriz-matriz o matriz-vector. El resultado siempre tiene el mismo tamaño que A*y, pero z puede ser más pequeño o un escalar.

Ejemplos

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

julia> muladd(A, B, z)
2×2 Matrix{Float64}:
   3.0    3.0
 107.0  107.0

inv(x)

Devuelve el inverso multiplicativo de x, de tal manera que x*inv(x) o inv(x)*x produce one(x) (la identidad multiplicativa) hasta errores de redondeo.

Si x es un número, esto es esencialmente lo mismo que one(x)/x, pero para algunos tipos inv(x) puede ser ligeramente más eficiente.

Ejemplos

julia> inv(2)
0.5

julia> inv(1 + 2im)
0.2 - 0.4im

julia> inv(1 + 2im) * (1 + 2im)
1.0 + 0.0im

julia> inv(2//3)
3//2

div(x, y)
÷(x, y)

El cociente de la división euclidiana (entera). Generalmente equivalente a una operación matemática x/y sin una parte fraccionaria.

Véase también: cld, fld, rem, divrem.

Ejemplos

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

div(x, y, r::RoundingMode=RoundToZero)

El cociente de la división euclidiana (entera). Calcula x / y, redondeado a un entero de acuerdo con el modo de redondeo r. En otras palabras, la cantidad

round(x / y, r)

sin ningún redondeo intermedio.

Véase también fld y cld, que son casos especiales de esta función.

Ejemplos:

julia> div(4, 3, RoundToZero) # Coincide con div(4, 3)
1
julia> div(4, 3, RoundDown) # Coincide con fld(4, 3)
1
julia> div(4, 3, RoundUp) # Coincide con cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

fld(x, y)

El entero más grande menor o igual a x / y. Equivalente a div(x, y, RoundDown).

Véase también div, cld, fld1.

Ejemplos

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) con el tipo de elemento Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

Debido a que fld(x, y) implementa un redondeo hacia abajo estrictamente correcto basado en el valor verdadero de los números de punto flotante, pueden surgir situaciones poco intuitivas. Por ejemplo:

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

Lo que está sucediendo aquí es que el valor verdadero del número de punto flotante escrito como 0.1 es ligeramente mayor que el valor numérico 1/10, mientras que 6.0 representa el número 6 con precisión. Por lo tanto, el valor verdadero de 6.0 / 0.1 es ligeramente menor que 60. Al hacer la división, esto se redondea a precisamente 60.0, pero fld(6.0, 0.1) siempre toma el piso del valor verdadero, por lo que el resultado es 59.0.

cld(x, y)

El entero más pequeño mayor o igual que x / y. Equivalente a div(x, y, RoundUp).

Véase también div, fld.

Ejemplos

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjunto(::Vector{Int64}) con el tipo de elemento Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

mod(x::Integer, r::AbstractUnitRange)

Encuentra y en el rango r tal que $x ≡ y (mod n)$, donde n = length(r), es decir, y = mod(x - first(r), n) + first(r).

Ver también mod1.

Ejemplos

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

mod(x, y)
rem(x, y, RoundDown)

La reducción de x módulo y, o equivalentemente, el residuo de x después de la división redondeada hacia abajo por y, es decir, x - y*fld(x,y) si se calcula sin redondeo intermedio.

El resultado tendrá el mismo signo que y, y una magnitud menor que abs(y) (con algunas excepciones, ver la nota a continuación).

Véase también: rem, div, fld, mod1, invmod.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

Encuentra y::T tal que x ≡ y (mod n), donde n es el número de enteros representables en T, y y es un entero en [typemin(T),typemax(T)]. Si T puede representar cualquier entero (por ejemplo, T == BigInt), entonces esta operación corresponde a una conversión a T.

Ejemplos

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

rem(x, y)
%(x, y)

Resto de la división euclidiana, devolviendo un valor del mismo signo que x, y menor en magnitud que y. Este valor es siempre exacto.

Véase también: div, mod, mod1, divrem.

Ejemplos

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

rem(x, y, r::RoundingMode=RoundToZero)

Calcula el residuo de x después de la división entera por y, con el cociente redondeado de acuerdo con el modo de redondeo r. En otras palabras, la cantidad

x - y * round(x / y, r)

sin ningún redondeo intermedio.

• si r == RoundNearest, entonces el resultado es exacto, y está en el intervalo $[-|y| / 2, |y| / 2]$. Ver también RoundNearest.
• si r == RoundToZero (por defecto), entonces el resultado es exacto, y está en el intervalo $[0, |y|)$ si x es positivo, o $(-|y|, 0]$ de lo contrario. Ver también RoundToZero.
• si r == RoundDown, entonces el resultado está en el intervalo $[0, y)$ si y es positivo, o $(y, 0]$ de lo contrario. El resultado puede no ser exacto si x y y tienen signos diferentes, y abs(x) < abs(y). Ver también RoundDown.
• si r == RoundUp, entonces el resultado está en el intervalo $(-y, 0]$ si y es positivo, o $[0, -y)$ de lo contrario. El resultado puede no ser exacto si x y y tienen el mismo signo, y abs(x) < abs(y). Ver también RoundUp.
• si r == RoundFromZero, entonces el resultado está en el intervalo $(-y, 0]$ si y es positivo, o $[0, -y)$ de lo contrario. El resultado puede no ser exacto si x y y tienen el mismo signo, y abs(x) < abs(y). Ver también RoundFromZero.

Ejemplos:

julia> x = 9; y = 4;

julia> x % y  # igual a rem(x, y)
1

julia> x ÷ y  # igual a div(x, y)
2

julia> x == div(x, y) * y + rem(x, y)
true

rem2pi(x, r::RoundingMode)

Calcula el residuo de x después de la división entera por 2π, con el cociente redondeado de acuerdo con el modo de redondeo r. En otras palabras, la cantidad

x - 2π*round(x/(2π),r)

sin ningún redondeo intermedio. Esto utiliza internamente una aproximación de alta precisión de 2π, y por lo tanto dará un resultado más preciso que rem(x,2π,r)

• si r == RoundNearest, entonces el resultado está en el intervalo $[-π, π]$. Este será generalmente el resultado más preciso. Ver también RoundNearest.
• si r == RoundToZero, entonces el resultado está en el intervalo $[0, 2π]$ si x es positivo, o $[-2π, 0]$ de lo contrario. Ver también RoundToZero.
• si r == RoundDown, entonces el resultado está en el intervalo $[0, 2π]$. Ver también RoundDown.
• si r == RoundUp, entonces el resultado está en el intervalo $[-2π, 0]$. Ver también RoundUp.

Ejemplos

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

mod2pi(x)

Módulo después de la división por 2π, devolviendo en el rango $[0,2π)$.

Esta función calcula una representación de punto flotante del módulo después de la división por 2π numéricamente exacto, y por lo tanto no es exactamente lo mismo que mod(x,2π), que calcularía el módulo de x en relación con la división por el número de punto flotante 2π.

Ejemplos

julia> mod2pi(9*pi/4)
0.7853981633974481

divrem(x, y, r::RoundingMode=RoundToZero)

El cociente y el residuo de la división euclidiana. Equivalente a (div(x, y, r), rem(x, y, r)). Equivalentemente, con el valor predeterminado de r, esta llamada es equivalente a (x ÷ y, x % y).

Véase también: fldmod, cld.

Ejemplos

julia> divrem(3, 7)
(0, 3)

julia> divrem(7, 3)
(2, 1)

fldmod(x, y)

El cociente y el módulo redondeados hacia abajo después de la división. Un envoltorio de conveniencia para divrem(x, y, RoundDown). Equivalente a (fld(x, y), mod(x, y)).

Véase también: fld, cld, fldmod1.

fld1(x, y)

División entera, devolviendo un valor consistente con mod1(x,y)

Véase también mod1, fldmod1.

Ejemplos

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

mod1(x, y)

Módulo después de la división por piso, devolviendo un valor r tal que mod(r, y) == mod(x, y) en el rango $(0, y]$ para y positivo y en el rango $[y,0)$ para y negativo.

Con argumentos enteros y y positivo, esto es igual a mod(x, 1:y), y por lo tanto es natural para la indexación basada en 1. En comparación, mod(x, y) == mod(x, 0:y-1) es natural para cálculos con desplazamientos o saltos.

Véase también mod, fld1, fldmod1.

Ejemplos

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

fldmod1(x, y)

Devuelve (fld1(x,y), mod1(x,y)).

Véase también fld1, mod1.

//(num, den)

Divide dos enteros o números racionales, dando un resultado de Rational. Más generalmente, // se puede usar para la división racional exacta de otros tipos numéricos con componentes enteros o racionales, como números complejos con componentes enteros.

Tenga en cuenta que los argumentos de punto flotante (AbstractFloat) no están permitidos por // (incluso si los valores son racionales). Los argumentos deben ser subtipos de Integer, Rational, o compuestos de estos.

Ejemplos

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

julia> (1+2im) // (3+4im)
11//25 + 2//25*im

julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

Aproximar el número de punto flotante x como un número Rational con componentes del tipo de entero dado. El resultado diferirá de x por no más de tol.

Ejemplos

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

numerador(x)

Numerador de la representación racional de x.

Ejemplos

julia> numerador(2//3)
2

julia> numerador(4)
4

denominador(x)

Denominador de la representación racional de x.

Ejemplos

julia> denominador(2//3)
3

julia> denominador(4)
1

<<(x, n)

Operador de desplazamiento de bits a la izquierda, x << n. Para n >= 0, el resultado es x desplazado a la izquierda por n bits, llenando con 0s. Esto es equivalente a x * 2^n. Para n < 0, esto es equivalente a x >> -n.

Ejemplos

julia> Int8(3) << 2
12

julia> bitstring(Int8(3))
"00000011"

julia> bitstring(Int8(12))
"00001100"

Ver también >>, >>>, exp2, ldexp.

<<(B::BitVector, n) -> BitVector

Operador de desplazamiento de bits a la izquierda, B << n. Para n >= 0, el resultado es B con elementos desplazados n posiciones hacia atrás, llenando con valores false. Si n < 0, los elementos se desplazan hacia adelante. Equivalente a B >> -n.

Ejemplos

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

>>(x, n)

Operador de desplazamiento a la derecha, x >> n. Para n >= 0, el resultado es x desplazado a la derecha por n bits, llenando con 0s si x >= 0, 1s si x < 0, preservando el signo de x. Esto es equivalente a fld(x, 2^n). Para n < 0, esto es equivalente a x << -n.

Ejemplos

julia> Int8(13) >> 2
3

julia> bitstring(Int8(13))
"00001101"

julia> bitstring(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(-4))
"11111100"

Ver también >>>, <<.

>>(B::BitVector, n) -> BitVector

Operador de desplazamiento a la derecha, B >> n. Para n >= 0, el resultado es B con elementos desplazados n posiciones hacia adelante, llenando con valores false. Si n < 0, los elementos se desplazan hacia atrás. Equivalente a B << -n.

Ejemplos

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitVector:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0

>>>(x, n)

Operador de desplazamiento de bits a la derecha sin signo, x >>> n. Para n >= 0, el resultado es x desplazado a la derecha por n bits, llenando con 0s. Para n < 0, esto es equivalente a x << -n.

Para los tipos de enteros Unsigned, esto es equivalente a >>. Para los tipos de enteros Signed, esto es equivalente a signed(unsigned(x) >> n).

Ejemplos

julia> Int8(-14) >>> 2
60

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(60))
"00111100"

Los BigInts se tratan como si tuvieran tamaño infinito, por lo que no se requiere llenado y esto es equivalente a >>.

Véase también >>, <<.

>>>(B::BitVector, n) -> BitVector

Operador de desplazamiento a la derecha sin signo, B >>> n. Equivalente a B >> n. Consulta >> para más detalles y ejemplos.

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) implementa la rotación a nivel de bits. Devuelve el valor de x con sus bits rotados a la izquierda k veces. Un valor negativo de k rotará a la derecha en su lugar.

Véase también: <<, circshift, BitArray.

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

:expr

Cita una expresión expr, devolviendo el árbol de sintaxis abstracta (AST) de expr. El AST puede ser de tipo Expr, Symbol, o un valor literal. La sintaxis :identifier se evalúa a un Symbol.

Ver también: Expr, Symbol, Meta.parse

Ejemplos

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

range(inicio, fin, longitud)
range(inicio, fin; longitud, paso)
range(inicio; longitud, fin, paso)
range(;inicio, longitud, fin, paso)

Construye un arreglo especializado con elementos espaciados uniformemente y almacenamiento optimizado (un AbstractRange) a partir de los argumentos. Matemáticamente, un rango está determinado de manera única por cualquiera de los tres inicio, paso, fin y longitud. Las invocaciones válidas de range son:

• Llamar a range con cualquiera de los tres inicio, paso, fin, longitud.
• Llamar a range con dos de inicio, fin, longitud. En este caso, se asumirá que paso es uno. Si ambos argumentos son enteros, se devolverá un UnitRange.
• Llamar a range con uno de fin o longitud. Se asumirá que inicio y paso son uno.

Consulta Ayuda Extendida para más detalles sobre el tipo devuelto. También consulta logrange para puntos espaciados logarítmicamente.

Ejemplos

julia> range(1, longitud=100)
1:100

julia> range(1, fin=100)
1:100

julia> range(1, paso=5, longitud=100)
1:5:496

julia> range(1, paso=5, fin=100)
1:5:96

julia> range(1, 10, longitud=101)
1.0:0.09:10.0

julia> range(1, 100, paso=5)
1:5:96

julia> range(fin=10, longitud=5)
6:10

julia> range(fin=10, paso=1, longitud=5)
6:1:10

julia> range(inicio=1, paso=1, fin=10)
1:1:10

julia> range(; longitud = 10)
Base.OneTo(10)

julia> range(; fin = 6)
Base.OneTo(6)

julia> range(; fin = 6.5)
1.0:1.0:6.0

Si longitud no se especifica y fin - inicio no es un múltiplo entero de paso, se producirá un rango que termina antes de fin.

julia> range(1, 3.5, paso=2)
1.0:2.0:3.0

Se toma un cuidado especial para asegurar que los valores intermedios se calculen de manera racional. Para evitar esta sobrecarga inducida, consulta el constructor LinRange.

Ayuda Extendida

range producirá un Base.OneTo cuando los argumentos sean enteros y

• Solo se proporciona longitud
• Solo se proporciona fin

range producirá un UnitRange cuando los argumentos sean enteros y

• Solo se proporcionan inicio y fin
• Solo se proporcionan longitud y fin

No se produce un UnitRange si se proporciona paso, incluso si se especifica como uno.

Base.OneTo(n)

Define un AbstractUnitRange que se comporta como 1:n, con la distinción adicional de que el límite inferior está garantizado (por el sistema de tipos) que es 1.

StepRangeLen(         ref::R, step::S, len, [offset=1]) where {  R,S}
StepRangeLen{T,R,S}(  ref::R, step::S, len, [offset=1]) where {T,R,S}
StepRangeLen{T,R,S,L}(ref::R, step::S, len, [offset=1]) where {T,R,S,L}

Un rango r donde r[i] produce valores del tipo T (en la primera forma, T se deduce automáticamente), parametrizado por un valor de referencia, un step y la length. Por defecto, ref es el valor inicial r[1], pero alternativamente puedes proporcionarlo como el valor de r[offset] para algún otro índice 1 <= offset <= len. La sintaxis a:b o a:b:c, donde cualquiera de a, b o c son números de punto flotante, crea un StepRangeLen.

logrange(inicio, fin, longitud)
logrange(inicio, fin; longitud)

Construye un arreglo especializado cuyos elementos están espaciados logarítmicamente entre los puntos finales dados. Es decir, la razón de los elementos sucesivos es constante, calculada a partir de la longitud.

Esto es similar a geomspace en Python. A diferencia de PowerRange en Mathematica, especificas el número de elementos, no la razón. A diferencia de logspace en Python y Matlab, los argumentos inicio y fin son siempre el primer y último elemento del resultado, no potencias aplicadas a alguna base.

Ejemplos

julia> logrange(10, 4000, longitud=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # el elemento del medio es la media geométrica
true

julia> range(10, 40, longitud=3)[2] ≈ (10 + 40)/2  # media aritmética
true

julia> logrange(1f0, 32f0, 11)
11-element Base.LogRange{Float32, Float64}:
 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

julia> logrange(1, 1000, longitud=4) ≈ 10 .^ (0:3)
true

Consulta el tipo LogRange para más detalles.

Consulta también range para puntos espaciados linealmente.

LogRange{T}(start, stop, len) <: AbstractVector{T}

Un rango cuyos elementos están espaciados logarítmicamente entre start y stop, con el espaciado controlado por len. Devuelto por logrange.

Al igual que LinRange, los primeros y últimos elementos serán exactamente los proporcionados, pero los valores intermedios pueden tener pequeños errores de punto flotante. Estos se calculan utilizando los logaritmos de los puntos finales, que se almacenan en la construcción, a menudo en una precisión mayor que T.

Ejemplos

julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 1.41421, 2.0, 2.82843, 4.0

julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
 1.0, 1.414, 2.0, 2.828, 4.0

julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
 1.0e-310
 9.999999999999974e-309
 9.999999999999981e-307
 9.999999999999988e-305
 9.999999999999994e-303
 1.0e-300

julia> prevfloat(1e-308, 5) == ans[2]
true

Tenga en cuenta que el tipo de eltype entero T no está permitido. Use, por ejemplo, round.(Int, xs), o potencias explícitas de alguna base entera:

julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 8.0, 64.0, 512.0

julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]

==(x, y)

Operador de igualdad genérico. Recurre a ===. Debe ser implementado para todos los tipos con una noción de igualdad, basada en el valor abstracto que representa una instancia. Por ejemplo, todos los tipos numéricos se comparan por valor numérico, ignorando el tipo. Las cadenas se comparan como secuencias de caracteres, ignorando la codificación. Las colecciones del mismo tipo generalmente comparan sus conjuntos de claves, y si esos son ==, entonces comparan los valores para cada una de esas claves, devolviendo verdadero si todos esos pares son ==. Otras propiedades generalmente no se tienen en cuenta (como el tipo exacto).

Este operador sigue la semántica IEEE para números de punto flotante: 0.0 == -0.0 y NaN != NaN.

El resultado es de tipo Bool, excepto cuando uno de los operandos es missing, en cuyo caso se devuelve missing (lógica de tres valores). Las colecciones generalmente implementan lógica de tres valores similar a all, devolviendo missing si alguno de los operandos contiene valores missing y todos los demás pares son iguales. Usa isequal o === para obtener siempre un resultado de tipo Bool.

Implementación

Los nuevos tipos numéricos deben implementar esta función para dos argumentos del nuevo tipo, y manejar la comparación con otros tipos a través de reglas de promoción cuando sea posible.

isequal recurre a ==, por lo que los nuevos métodos de == serán utilizados por el tipo Dict para comparar claves. Si tu tipo se utilizará como clave de diccionario, también debe implementar hash.

Si algún tipo define ==, isequal y isless, entonces también debe implementar < para asegurar la consistencia de las comparaciones.

!=(x, y)
≠(x,y)

Operador de comparación de desigualdad. Siempre da la respuesta opuesta a ==.

Implementación

Los nuevos tipos generalmente no deben implementar esto y deben confiar en la definición de respaldo !=(x,y) = !(x==y) en su lugar.

Ejemplos

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

Crea una función que compara su argumento con x usando !=, es decir, una función equivalente a y -> y != x. La función devuelta es de tipo Base.Fix2{typeof(!=)}, que se puede usar para implementar métodos especializados.

!==(x, y)
≢(x,y)

Siempre da la respuesta opuesta a ===.

Ejemplos

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

Operador de comparación menor que. Recurre a isless. Debido al comportamiento de los valores NaN de punto flotante, este operador implementa un orden parcial.

Implementación

Los nuevos tipos con un orden parcial canónico deben implementar esta función para dos argumentos del nuevo tipo. Los tipos con un orden total canónico deben implementar isless en su lugar.

Véase también isunordered.

Ejemplos

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

Crea una función que compara su argumento con x usando <, es decir, una función equivalente a y -> y < x. La función devuelta es de tipo Base.Fix2{typeof(<)}, que se puede usar para implementar métodos especializados.

<=(x, y)
≤(x,y)

Operador de comparación menor o igual. Recurre a (x < y) | (x == y).

Ejemplos

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

Crea una función que compara su argumento con x usando <=, es decir, una función equivalente a y -> y <= x. La función devuelta es de tipo Base.Fix2{typeof(<=)}, que se puede usar para implementar métodos especializados.

>(x, y)

Operador de comparación mayor que. Se basa en y < x.

Implementación

En general, los nuevos tipos deberían implementar < en lugar de esta función, y confiar en la definición de respaldo >(x, y) = y < x.

Ejemplos

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

Crea una función que compara su argumento con x usando >, es decir, una función equivalente a y -> y > x. La función devuelta es de tipo Base.Fix2{typeof(>)}, que se puede usar para implementar métodos especializados.

>=(x, y)
≥(x,y)

Operador de comparación mayor o igual. Recurre a y <= x.

Ejemplos

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

Crea una función que compara su argumento con x usando >=, es decir, una función equivalente a y -> y >= x. La función devuelta es de tipo Base.Fix2{typeof(>=)}, que se puede usar para implementar métodos especializados.

cmp(x,y)

Devuelve -1, 0 o 1 dependiendo de si x es menor que, igual a, o mayor que y, respectivamente. Utiliza el orden total implementado por isless.

Ejemplos

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

cmp(<, x, y)

Devuelve -1, 0 o 1 dependiendo de si x es menor que, igual a, o mayor que y, respectivamente. El primer argumento especifica una función de comparación de menor que a utilizar.

cmp(a::AbstractString, b::AbstractString) -> Int

Compara dos cadenas. Devuelve 0 si ambas cadenas tienen la misma longitud y el carácter en cada índice es el mismo en ambas cadenas. Devuelve -1 si a es un prefijo de b, o si a precede a b en orden alfabético. Devuelve 1 si b es un prefijo de a, o si b precede a a en orden alfabético (técnicamente, orden lexicográfico por puntos de código Unicode).

Ejemplos

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

~(x)

No bit a bit.

Véase también: !, &, |.

Ejemplos

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

Y bit a bit. Implementa lógica de tres valores, devolviendo missing si un operando es missing y el otro es true. Agrega paréntesis para la forma de aplicación de función: (&)(x, y).

Ver también: |, xor, &&.

Ejemplos

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

O lógico. Implementa lógica de tres valores, devolviendo missing si un operando es missing y el otro es false.

Véase también: &, xor, ||.

Ejemplos

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

xor(x, y)
⊻(x, y)

O exclusivo a nivel de bits de x e y. Implementa lógica de tres valores, devolviendo missing si uno de los argumentos es missing.

La operación infija a ⊻ b es un sinónimo de xor(a,b), y ⊻ se puede escribir completando con tabulador \xor o \veebar en el REPL de Julia.

Ejemplos

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitVector:
 0
 1
 0

nand(x, y)
⊼(x, y)

Nand a nivel de bits (no y) de x e y. Implementa lógica de tres valores, devolviendo missing si uno de los argumentos es missing.

La operación infija a ⊼ b es un sinónimo de nand(a,b), y ⊼ se puede escribir completando con tabulador \nand o \barwedge en el REPL de Julia.

Ejemplos

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

julia> [true; true; false] .⊼ [true; false; false]
3-element BitVector:
 0
 1
 1

nor(x, y)
⊽(x, y)

NOR a nivel de bits (no o) de x y y. Implementa lógica de tres valores, devolviendo missing si uno de los argumentos es missing y el otro no es true.

La operación infija a ⊽ b es un sinónimo de nor(a,b), y ⊽ se puede escribir completando con tabulador \nor o \barvee en el REPL de Julia.

Ejemplos

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

julia> [true; true; false] .⊽ [true; false; false]
3-element BitVector:
 0
 0
 1

!(x)

Negación booleana. Implementa lógica de tres valores, devolviendo missing si x es missing.

Véase también ~ para negación a nivel de bits.

Ejemplos

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

!f::Function

Negación de función de predicado: cuando el argumento de ! es una función, devuelve una función compuesta que calcula la negación booleana de f.

Véase también ∘.

Ejemplos

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isletter, str)
"εδxyδfxfyε"

julia> filter(!isletter, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

x && y

Cortocircuito booleano AND.

Véase también &, el operador ternario ? :, y la sección del manual sobre flujo de control.

Ejemplos

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("se esperaba un x positivo")
false

x || y

OR boolean de cortocircuito.

Véase también: |, xor, &&.

Ejemplos

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("¡ninguno es verdadero!")
true

isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

Comparación de igualdad inexacta. Dos números se comparan como iguales si su distancia relativa o su distancia absoluta está dentro de los límites de tolerancia: isapprox devuelve true si norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))). La atol predeterminada (tolerancia absoluta) es cero y la rtol predeterminada (tolerancia relativa) depende de los tipos de x e y. El argumento clave nans determina si los valores NaN se consideran iguales o no (por defecto es falso).

Para valores de punto flotante reales o complejos, si no se especifica un atol > 0, la rtol predeterminada es la raíz cuadrada de eps del tipo de x o y, el que sea mayor (menos preciso). Esto corresponde a requerir igualdad de aproximadamente la mitad de los dígitos significativos. De lo contrario, por ejemplo, para argumentos enteros o si se proporciona un atol > 0, la rtol predeterminada es cero.

El argumento clave norm predeterminado es abs para numéricos (x,y) y LinearAlgebra.norm para arreglos (donde a veces es útil una elección alternativa de norm). Cuando x e y son arreglos, si norm(x-y) no es finito (es decir, ±Inf o NaN), la comparación se reduce a verificar si todos los elementos de x e y son aproximadamente iguales componente por componente.

El operador binario ≈ es equivalente a isapprox con los argumentos predeterminados, y x ≉ y es equivalente a !isapprox(x,y).

Ten en cuenta que x ≈ 0 (es decir, comparar con cero con las tolerancias predeterminadas) es equivalente a x == 0 ya que la atol predeterminada es 0. En tales casos, debes proporcionar un atol apropiado (o usar norm(x) ≤ atol) o reorganizar tu código (por ejemplo, usar x ≈ y en lugar de x - y ≈ 0). No es posible elegir un atol distinto de cero automáticamente porque depende de la escala general (las "unidades") de tu problema: por ejemplo, en x - y ≈ 0, atol=1e-9 es una tolerancia absurdamente pequeña si x es el radio de la Tierra en metros, pero una tolerancia absurdamente grande si x es el radio de un átomo de hidrógeno en metros.

Ejemplos

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # usando `norm`
true

isapprox(x; kwargs...) / ≈(x; kwargs...)

Crea una función que compara su argumento con x usando ≈, es decir, una función equivalente a y -> y ≈ x.

Los argumentos de palabra clave admitidos aquí son los mismos que los de isapprox con 2 argumentos.

sin(x)

Calcula el seno de x, donde x está en radianes.

Véase también sind, sinpi, sincos, cis, asin.

Ejemplos

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

cos(x)

Calcule el coseno de x, donde x está en radianes.

Véase también cosd, cospi, sincos, cis.

sincos(x)

Calcula simultáneamente el seno y el coseno de x, donde x está en radianes, devolviendo una tupla (seno, coseno).

Véase también cis, sincospi, sincosd.

tan(x)

Calcule la tangente de x, donde x está en radianes.

sind(x)

Calcula el seno de x, donde x está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

cosd(x)

Calcula el coseno de x, donde x está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

tand(x)

Calcula la tangente de x, donde x está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

sincosd(x)

Calcula simultáneamente el seno y el coseno de x, donde x está en grados.

sinpi(x)

Calcula $\sin(\pi x)$ de manera más precisa que sin(pi*x), especialmente para valores grandes de x.

Consulta también sind, cospi, sincospi.

cospi(x)

Calcula $\cos(\pi x)$ de manera más precisa que cos(pi*x), especialmente para valores grandes de x.

tanpi(x)

Calcula $\tan(\pi x)$ de manera más precisa que tan(pi*x), especialmente para valores grandes de x.

Véase también tand, sinpi, cospi, sincospi.

sincospi(x)

Calcula simultáneamente sinpi(x) y cospi(x) (el seno y el coseno de π*x, donde x está en radianes), devolviendo una tupla (seno, coseno).

Véase también: cispi, sincosd, sinpi.

sinh(x)

Calcule el seno hiperbólico de x.

cosh(x)

Calcule el coseno hiperbólico de x.

tanh(x)

Calcula la tangente hiperbólica de x.

Véase también tan, atanh.

Ejemplos

julia> tanh.(-3:3f0)  # Aquí 3f0 es un Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

asin(x)

Calcula el seno inverso de x, donde la salida está en radianes.

Véase también asind para la salida en grados.

Ejemplos

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

acos(x)

Calcula el coseno inverso de x, donde la salida está en radianes

atan(y)
atan(y, x)

Calcula la tangente inversa de y o y/x, respectivamente.

Para un argumento real, este es el ángulo en radianes entre el eje positivo x y el punto (1, y), devolviendo un valor en el intervalo $[-\pi/2, \pi/2]$.

Para dos argumentos, este es el ángulo en radianes entre el eje positivo x y el punto (x, y), devolviendo un valor en el intervalo $[-\pi, \pi]$. Esto corresponde a una función estándar atan2. Ten en cuenta que por convención atan(0.0,x) se define como $\pi$ y atan(-0.0,x) se define como $-\pi$ cuando x < 0.

Consulta también atand para grados.

Ejemplos

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

asind(x)

Calcula el seno inverso de x, donde la salida está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

acosd(x)

Calcula el coseno inverso de x, donde la salida está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

atand(y)
atand(y,x)

Calcula la tangente inversa de y o y/x, respectivamente, donde la salida está en grados.

sec(x)

Calcula la secante de x, donde x está en radianes.

csc(x)

Calcula la cosecante de x, donde x está en radianes.

cot(x)

Calcula la cotangente de x, donde x está en radianes.

secd(x)

Calcula la secante de x, donde x está en grados.

cscd(x)

Calcula la cosecante de x, donde x está en grados.

cotd(x)

Calcula la cotangente de x, donde x está en grados.

asec(x)

Calcula la secante inversa de x, donde la salida está en radianes.

acsc(x)

Calcula el cosecante inverso de x, donde la salida está en radianes.

acot(x)

Calcula la cotangente inversa de x, donde la salida está en radianes.

asecd(x)

Calcula la secante inversa de x, donde la salida está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

acscd(x)

Calcula el cosecante inverso de x, donde la salida está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

acotd(x)

Calcula la cotangente inversa de x, donde la salida está en grados. Si x es una matriz, x debe ser una matriz cuadrada.

sech(x)

Calcula la secante hiperbólica de x.

csch(x)

Calcula la cosecante hiperbólica de x.

coth(x)

Calcula la cotangente hiperbólica de x.

asinh(x)

Calcula el seno hiperbólico inverso de x.

acosh(x)

Calcula el coseno hiperbólico inverso de x.

atanh(x)

Calcula la tangente hiperbólica inversa de x.

asech(x)

Calcule el secante hiperbólico inverso de x.

acsch(x)

Calcula la cosecante hiperbólica inversa de x.

acoth(x)

Calcula el cotangente hiperbólico inverso de x.

sinc(x)

Calcule la función sinc normalizada $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ si $x \neq 0$, y $1$ si $x = 0$.

Véase también cosc, su derivada.

cosc(x)

Calcule $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ si $x \neq 0$, y $0$ si $x = 0$. Esta es la derivada de sinc(x).

Véase también sinc.

deg2rad(x)

Convierte x de grados a radianes.

Véase también rad2deg, sind, pi.

Ejemplos

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

Convierte x de radianes a grados.

Véase también deg2rad.

Ejemplos

julia> rad2deg(pi)
180.0

hypot(x, y)

Calcula la hipotenusa $\sqrt{|x|^2+|y|^2}$ evitando desbordamiento y subdesbordamiento.

Este código es una implementación del algoritmo descrito en: Un algoritmo mejorado para hypot(a,b) por Carlos F. Borges. El artículo está disponible en línea en arXiv en el enlace https://arxiv.org/abs/1904.09481

hypot(x...)

Calcula la hipotenusa $\sqrt{\sum |x_i|^2}$ evitando desbordamiento y subdesbordamiento.

Consulta también norm en la biblioteca estándar LinearAlgebra.

Ejemplos

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 desborda
ERROR: DomainError with -2.914184810805068e18:
sqrt fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta sqrt(Complex(x)).
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

log(x)

Calcula el logaritmo natural de x.

Lanza DomainError para argumentos Real negativos. Usa argumentos complejos para obtener resultados complejos. Tiene un corte de rama a lo largo del eje real negativo, para el cual -0.0im se considera por debajo del eje.

Véase también ℯ, log1p, log2, log10.

Ejemplos

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

julia> log.(exp.(-1:1))
Vector{Float64} de 3 elementos:
 -1.0
  0.0
  1.0

log(b,x)

Calcula el logaritmo de x en base b. Lanza DomainError para argumentos Real negativos.

Ejemplos

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

Calcula el logaritmo de x en base 2. Lanza DomainError para argumentos Real negativos.

Véase también: exp2, ldexp, ispow2.

Ejemplos

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError con -2.0:
log2 fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta log2(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
Vector{Float64} de 3 elementos:
 -1.0
  0.0
  1.0

log10(x)

Calcula el logaritmo de x en base 10. Lanza DomainError para argumentos Real negativos.

Ejemplos

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError con -2.0:
log10 fue llamado con un argumento real negativo pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta log10(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

Logaritmo natural preciso de 1+x. Lanza DomainError para argumentos Real menores que -1.

Ejemplos

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError con -2.0:
log1p fue llamado con un argumento real < -1 pero solo devolverá un resultado complejo si se llama con un argumento complejo. Intenta log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

Devuelve (x,exp) tal que x tiene una magnitud en el intervalo $[1/2, 1)$ o 0, y val es igual a $x \times 2^{exp}$.

Véase también significand, exponent, ldexp.

Ejemplos

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # intervalo [1, 2) en su lugar
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # el exponente daría un error
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

Calcula la exponencial de base natural de x, en otras palabras $ℯ^x$.

Véase también exp2, exp10 y cis.

Ejemplos

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

exp2(x)

Calcula la exponencial de base 2 de x, en otras palabras $2^x$.

Véase también ldexp, <<.

Ejemplos

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

exp10(x)

Calcula la exponencial en base 10 de x, en otras palabras $10^x$.

Ejemplos

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

Calcula $x \times 2^n$.

Véase también frexp, exponent.

Ejemplos

julia> ldexp(5.0, 2)
20.0

modf(x)

Devuelve una tupla (fpart, ipart) de las partes fraccionaria e integral de un número. Ambas partes tienen el mismo signo que el argumento.

Ejemplos

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

expm1(x)

Calcula con precisión $e^x-1$. Evita la pérdida de precisión involucrada en la evaluación directa de exp(x)-1 para valores pequeños de x.

Ejemplos

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

Redondea el número x.

Sin argumentos de palabra clave, x se redondea a un valor entero, devolviendo un valor del tipo T, o del mismo tipo que x si no se proporciona T. Se lanzará un InexactError si el valor no es representable por T, similar a convert.

Si se proporciona el argumento de palabra clave digits, se redondea al número especificado de dígitos después del punto decimal (o antes si es negativo), en base base.

Si se proporciona el argumento de palabra clave sigdigits, se redondea al número especificado de dígitos significativos, en base base.

El RoundingMode r controla la dirección del redondeo; el valor predeterminado es RoundNearest, que redondea al entero más cercano, con empates (valores fraccionarios de 0.5) redondeados al entero par más cercano. Tenga en cuenta que round puede dar resultados incorrectos si se cambia el modo de redondeo global (ver rounding).

Al redondear a un tipo de punto flotante, se redondeará a enteros representables por ese tipo (y Inf) en lugar de enteros verdaderos. Inf se trata como un ulp mayor que el floatmax(T) a efectos de determinar "más cercano", similar a convert.

Ejemplos

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

Extensiones

Para extender round a nuevos tipos numéricos, generalmente es suficiente definir Base.round(x::NewType, r::RoundingMode). ```

RoundingMode

Un tipo utilizado para controlar el modo de redondeo de las operaciones de punto flotante (a través de las funciones rounding/setrounding), o como argumentos opcionales para redondear al entero más cercano (a través de la función round).

Los modos de redondeo actualmente soportados son:

• RoundNearest (predeterminado)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

El modo de redondeo predeterminado. Redondea al entero más cercano, con empates (valores fraccionarios de 0.5) redondeados al entero par más cercano.

RoundNearestTiesAway

Redondea al entero más cercano, con empates redondeados alejándose de cero (comportamiento de C/C++ round).

RoundNearestTiesUp

Redondea al entero más cercano, con empates redondeados hacia el infinito positivo (comportamiento de round de Java/JavaScript).

RoundToZero

round usar este modo de redondeo es un alias para trunc.

RoundFromZero

Redondea alejándose de cero.

Ejemplos

julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06

RoundUp

round usar este modo de redondeo es un alias para ceil.

RedondearHaciaAbajo

round usando este modo de redondeo es un alias para floor.

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

Devuelve el valor integral más cercano del mismo tipo que el valor complejo z, rompiendo empates utilizando los RoundingMode especificados. El primer RoundingMode se utiliza para redondear los componentes reales, mientras que el segundo se utiliza para redondear los componentes imaginarios.

RoundingModeReal y RoundingModeImaginary se establecen de forma predeterminada en RoundNearest, que redondea al entero más cercano, con empates (valores fraccionarios de 0.5) redondeados al entero par más cercano.

Ejemplos

julia> round(3.14 + 4.5im)
3.0 + 4.0im

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])

ceil(x) devuelve el valor integral más cercano del mismo tipo que x que es mayor o igual a x.

ceil(T, x) convierte el resultado al tipo T, lanzando un InexactError si el valor redondeado no es representable como un T.

Las palabras clave digits, sigdigits y base funcionan como para round.

Para soportar ceil para un nuevo tipo, define Base.round(x::NewType, ::RoundingMode{:Up}).

floor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])

floor(x) devuelve el valor integral más cercano del mismo tipo que x que es menor o igual a x.

floor(T, x) convierte el resultado al tipo T, lanzando un InexactError si el valor redondeado no es representable como T.

Las palabras clave digits, sigdigits y base funcionan como para round.

Para soportar floor para un nuevo tipo, define Base.round(x::NewType, ::RoundingMode{:Down}).

trunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])

trunc(x) devuelve el valor integral más cercano del mismo tipo que x cuyo valor absoluto es menor o igual al valor absoluto de x.

trunc(T, x) convierte el resultado al tipo T, lanzando un InexactError si el valor truncado no es representable como T.

Las palabras clave digits, sigdigits y base funcionan como para round.

Para soportar trunc para un nuevo tipo, define Base.round(x::NewType, ::RoundingMode{:ToZero}).

Véase también: %, floor, unsigned, unsafe_trunc.

Ejemplos

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

Devuelve el valor integral más cercano del tipo T cuyo valor absoluto es menor o igual al valor absoluto de x. Si el valor no es representable por T, se devolverá un valor arbitrario. Ver también trunc.

Ejemplos

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

Devuelve el mínimo de los argumentos, con respecto a isless. Si alguno de los argumentos es missing, devuelve missing. Consulta también la función minimum para obtener el elemento mínimo de una colección.

Ejemplos

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

Devuelve el máximo de los argumentos, con respecto a isless. Si alguno de los argumentos es missing, devuelve missing. Consulta también la función maximum para obtener el elemento máximo de una colección.

Ejemplos

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

Devuelve (min(x,y), max(x,y)).

Véase también extrema que devuelve (minimum(x), maximum(x)).

Ejemplos

julia> minmax('c','b')
('b', 'c')

clamp(x, lo, hi)

Devuelve x si lo <= x <= hi. Si x > hi, devuelve hi. Si x < lo, devuelve lo. Los argumentos se promueven a un tipo común.

Véase también clamp!, min, max.

Ejemplos

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11, 8, 5], 10, 6)  # un ejemplo donde lo > hi
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

Limita x entre typemin(T) y typemax(T) y convierte el resultado al tipo T.

Véase también trunc.

Ejemplos

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

clamp(x::Integer, r::AbstractUnitRange)

Limitar x para que esté dentro del rango r.

clamp!(array::AbstractArray, lo, hi)

Restringe los valores en array al rango especificado, en su lugar. Ver también clamp.

Ejemplos

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) con el tipo eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

abs(x)

El valor absoluto de x.

Cuando abs se aplica a enteros con signo, puede ocurrir un desbordamiento, lo que resulta en el retorno de un valor negativo. Este desbordamiento ocurre solo cuando abs se aplica al valor mínimo representable de un entero con signo. Es decir, cuando x == typemin(typeof(x)), abs(x) == x < 0, no -x como podría esperarse.

Véase también: abs2, unsigned, sign.

Ejemplos

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # desbordamiento en typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

Comprobado

El módulo Comprobado proporciona funciones aritméticas para los tipos de Enteros con signo y sin signo incorporados que lanzan un error cuando ocurre un desbordamiento. Se nombran como checked_sub, checked_div, etc. Además, add_with_overflow, sub_with_overflow, mul_with_overflow devuelven tanto los resultados sin comprobar como un valor booleano que denota la presencia de un desbordamiento.

Base.checked_abs(x)

Calcula abs(x), verificando errores de desbordamiento donde sea aplicable. Por ejemplo, los enteros con signo en complemento a dos estándar (por ejemplo, Int) no pueden representar abs(typemin(Int)), lo que lleva a un desbordamiento.

La protección contra desbordamientos puede imponer una penalización de rendimiento perceptible.

Base.checked_neg(x)

Calcula -x, verificando errores de desbordamiento donde sea aplicable. Por ejemplo, los enteros con signo de complemento a dos estándar (por ejemplo, Int) no pueden representar -typemin(Int), lo que lleva a un desbordamiento.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_add(x, y)

Calcula x+y, verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_sub(x, y)

Calcula x-y, verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_mul(x, y)

Calcula x*y, verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_div(x, y)

Calcula div(x,y), verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_rem(x, y)

Calcula x%y, verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_fld(x, y)

Calcula fld(x,y), verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_mod(x, y)

Calcula mod(x,y), verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_cld(x, y)

Calcula cld(x,y), verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.checked_pow(x, y)

Calcula ^(x,y), verificando errores de desbordamiento donde sea aplicable.

La protección contra desbordamiento puede imponer una penalización de rendimiento perceptible.

Base.add_with_overflow(x, y) -> (r, f)

Calcula r = x+y, con la bandera f que indica si ha ocurrido un desbordamiento.

Base.sub_with_overflow(x, y) -> (r, f)

Calcula r = x-y, con la bandera f que indica si ha ocurrido un desbordamiento.

Base.mul_with_overflow(x, y) -> (r, f)

Calcula r = x*y, con la bandera f que indica si ha ocurrido un desbordamiento.

abs2(x)

Valor absoluto al cuadrado de x.

Esto puede ser más rápido que abs(x)^2, especialmente para números complejos donde abs(x) requiere una raíz cuadrada a través de hypot.

Véase también abs, conj, real.

Ejemplos

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
30

copysign(x, y) -> z

Devuelve z que tiene la magnitud de x y el mismo signo que y.

Ejemplos

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

Devuelve cero si x==0 y $x/|x|$ de lo contrario (es decir, ±1 para x real).

Véase también signbit, zero, copysign, flipsign.

Ejemplos

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

julia> sign(0 + im)
0.0 + 1.0im

signbit(x)

Devuelve true si el valor del signo de x es negativo, de lo contrario false.

Véase también sign y copysign.

Ejemplos

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

Devuelve x con su signo cambiado si y es negativo. Por ejemplo abs(x) = flipsign(x,x).

Ejemplos

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

Devuelve $\sqrt{x}$.

Lanza DomainError para argumentos Real negativos. Usa argumentos negativos complejos en su lugar. Ten en cuenta que sqrt tiene un corte de rama a lo largo del eje real negativo.

El operador prefijo √ es equivalente a sqrt.

Véase también: hypot.

Ejemplos

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError con -81.0:
Resultado NaN para entrada no-NaN.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im está por debajo del corte de rama
0.0 - 9.0im

julia> .√(1:4)
Vector de 4 elementos{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

isqrt(n::Integer)

Raíz cuadrada entera: el mayor entero m tal que m*m <= n.

julia> isqrt(5)
2

cbrt(x::Real)

Devuelve la raíz cúbica de x, es decir, $x^{1/3}$. Se aceptan valores negativos (devolviendo la raíz real negativa cuando $x < 0$).

El operador prefijo ∛ es equivalente a cbrt.

Ejemplos

julia> cbrt(big(27))
3.0

julia> cbrt(big(-27))
-3.0

real(z)

Devuelve la parte real del número complejo z.

Véase también: imag, reim, complex, isreal, Real.

Ejemplos

julia> real(1 + 3im)
1

real(T::Type)

Devuelve el tipo que representa la parte real de un valor del tipo T. por ejemplo: para T == Complex{R}, devuelve R. Equivalente a typeof(real(zero(T))).

Ejemplos

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

Devuelve un array que contiene la parte real de cada entrada en el array A.

Equivalente a real.(A), excepto que cuando eltype(A) <: Real A se devuelve sin copiar, y que cuando A tiene cero dimensiones, se devuelve un array de 0 dimensiones (en lugar de un escalar).

Ejemplos

julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 1
 0
 3

julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2

imag(z)

Devuelve la parte imaginaria del número complejo z.

Véase también: conj, reim, adjoint, angle.

Ejemplos

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

Devuelve un array que contiene la parte imaginaria de cada entrada en el array A.

Equivalente a imag.(A), excepto que cuando A tiene cero dimensiones, se devuelve un array de 0 dimensiones (en lugar de un escalar).

Ejemplos

julia> imag([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 0
 2
 4

julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1

reim(z)

Devuelve una tupla de las partes real e imaginaria del número complejo z.

Ejemplos

julia> reim(1 + 3im)
(1, 3)

reim(A::AbstractArray)

Devuelve una tupla de dos arreglos que contienen respectivamente la parte real y la parte imaginaria de cada entrada en A.

Equivalente a (real.(A), imag.(A)), excepto que cuando eltype(A) <: Real A se devuelve sin copiar para representar la parte real, y que cuando A tiene cero dimensiones, se devuelve un arreglo de 0 dimensiones (en lugar de un escalar).

Ejemplos

julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])

julia> reim(fill(2 - im))
(fill(2), fill(-1))

conj(z)

Calcula el conjugado complejo de un número complejo z.

Véase también: angle, adjoint.

Ejemplos

julia> conj(1 + 3im)
1 - 3im

conj(A::AbstractArray)

Devuelve un array que contiene el conjugado complejo de cada entrada en el array A.

Equivalente a conj.(A), excepto que cuando eltype(A) <: Real A se devuelve sin copiar, y que cuando A tiene cero dimensiones, se devuelve un array de 0 dimensiones (en lugar de un escalar).

Ejemplos

julia> conj([1, 2im, 3 + 4im])
3-element Vector{Complex{Int64}}:
 1 + 0im
 0 - 2im
 3 - 4im

julia> conj(fill(2 - im))
0-dimensional Array{Complex{Int64}, 0}:
2 + 1im

angle(z)

Calcula el ángulo de fase en radianes de un número complejo z.

Devuelve un número -pi ≤ angle(z) ≤ pi, y es, por lo tanto, discontinuo a lo largo del eje real negativo.

Véase también: atan, cis, rad2deg.

Ejemplos

julia> rad2deg(angle(1 + im))
45.0

julia> rad2deg(angle(1 - im))
-45.0

julia> rad2deg(angle(-1 + 1e-20im))
180.0

julia> rad2deg(angle(-1 - 1e-20im))
-180.0

cis(x)

Método más eficiente para exp(im*x) utilizando la fórmula de Euler: $\cos(x) + i \sin(x) = \exp(i x)$.

Ver también cispi, sincos, exp, angle.

Ejemplos

julia> cis(π) ≈ -1
true

cispi(x)

Método más preciso para cis(pi*x) (especialmente para grandes x).

Véase también cis, sincospi, exp, angle.

Ejemplos

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.03055685464595456im

binomial(n::Integer, k::Integer)

El coeficiente binomial $\binom{n}{k}$, siendo el coeficiente del término $k$ en la expansión polinómica de $(1+x)^n$.

Si $n$ es no negativo, entonces es el número de maneras de elegir k de n elementos:

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

donde $n!$ es la función factorial.

Si $n$ es negativo, entonces se define en términos de la identidad

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

Ver también factorial.

Ejemplos

julia> binomial(5, 3)
10

julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10

julia> binomial(-5, 3)
-35

Enlaces externos

• Coeficiente binomial en Wikipedia.

```

binomial(x::Number, k::Integer)

El coeficiente binomial generalizado, definido para k ≥ 0 por el polinomio

\[\frac{1}{k!} \prod_{j=0}^{k-1} (x - j)\]

Cuando k < 0 devuelve cero.

Para el caso de x entero, esto es equivalente al coeficiente binomial entero ordinario

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

Generalizaciones adicionales a k no entero son matemáticamente posibles, pero implican la función Gamma y/o la función beta, que no están proporcionadas por la biblioteca estándar de Julia, pero están disponibles en paquetes externos como SpecialFunctions.jl.

Enlaces externos

• Coeficiente binomial en Wikipedia.

factorial(n::Integer)

Factorial de n. Si n es un Integer, el factorial se calcula como un entero (promovido a al menos 64 bits). Ten en cuenta que esto puede desbordarse si n no es pequeño, pero puedes usar factorial(big(n)) para calcular el resultado exactamente en precisión arbitraria.

Ver también binomial.

Ejemplos

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 es demasiado grande para buscar en la tabla; considera usar `factorial(big(21))` en su lugar
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

Enlaces externos

• Factorial en Wikipedia.

```

gcd(x, y...)

Máximo común divisor (positivo) (o cero si todos los argumentos son cero). Los argumentos pueden ser números enteros y racionales.

Ejemplos

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

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

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

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

julia> gcd(0, 0, 10, 15)
5

lcm(x, y...)

Múltiplo común (positivo) mínimo (o cero si algún argumento es cero). Los argumentos pueden ser números enteros y racionales.

Ejemplos

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

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

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

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

julia> lcm(1, 3, 5, 7)
105

gcdx(a, b)

Calcula el máximo común divisor (positivo) de a y b y sus coeficientes de Bézout, es decir, los coeficientes enteros u y v que satisfacen $ua+vb = d = gcd(a, b)$. gcdx(a, b) devuelve $(d, u, v)$.

Los argumentos pueden ser números enteros y racionales.

Ejemplos

julia> gcdx(12, 42)
(6, -3, 1)

julia> gcdx(240, 46)
(2, -9, 47)

ispow2(n::Number) -> Bool

Prueba si n es una potencia entera de dos.

Véase también count_ones, prevpow, nextpow.

Ejemplos

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

El más pequeño a^n no menor que x, donde n es un entero no negativo. a debe ser mayor que 1, y x debe ser mayor que 0.

Véase también prevpow.

Ejemplos

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

El mayor a^n que no es mayor que x, donde n es un entero no negativo. a debe ser mayor que 1, y x no debe ser menor que 1.

Véase también nextpow, isqrt.

Ejemplos

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextprod(factors::Union{Tuple,AbstractVector}, n)

Siguiente entero mayor o igual a n que se puede escribir como $\prod k_i^{p_i}$ para enteros $p_1$, $p_2$, etcétera, para factores $k_i$ en factors.

Ejemplos

julia> nextprod((2, 3), 105)
108

julia> 2^2 * 3^3
108

invmod(n::Integer, m::Integer)

Toma el inverso de n módulo m: y tal que $n y = 1 \pmod m$, y $div(y,m) = 0$. Esto lanzará un error si $m = 0$, o si $gcd(n,m) \neq 1$.

Ejemplos

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}

Calcula el inverso modular de n en el anillo entero de tipo T, es decir, módulo 2^N donde N = 8*sizeof(T) (por ejemplo, N = 32 para Int32). En otras palabras, estos métodos satisfacen las siguientes identidades:

n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1

Ten en cuenta que * aquí es multiplicación modular en el anillo entero, T.

Especificar el módulo implícito por un tipo de entero como un valor explícito es a menudo inconveniente, ya que el módulo es por definición demasiado grande para ser representado por el tipo.

El inverso modular se calcula de manera mucho más eficiente que el caso general utilizando el algoritmo descrito en https://arxiv.org/pdf/2204.04342.pdf.

powermod(x::Integer, p::Integer, m)

Calcula $x^p \pmod m$.

Ejemplos

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

ndigits(n::Integer; base::Integer=10, pad::Integer=1)

Calcula el número de dígitos en el entero n escrito en base base (la base no debe estar en [-1, 0, 1]), opcionalmente rellenado con ceros hasta un tamaño especificado (el resultado nunca será menor que pad).

Véase también digits, count_ones.

Ejemplos

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

julia> string(1022, base=16)
"3fe"

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

El operador de reducción utilizado en sum. La principal diferencia con + es que los enteros pequeños se promueven a Int/UInt.

widemul(x, y)

Multiplica x e y, dando el resultado como un tipo más grande.

Véase también promote, Base.add_sum.

Ejemplos

julia> widemul(Float32(3.0), 4.0) isa BigFloat
true

julia> typemax(Int8) * typemax(Int8)
1

julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
16129

evalpoly(x, p)

Evalúa el polinomio $\sum_k x^{k-1} p[k]$ para los coeficientes p[1], p[2], ...; es decir, los coeficientes se dan en orden ascendente por potencia de x. Los bucles se desenrollan en tiempo de compilación si el número de coeficientes se conoce estáticamente, es decir, cuando p es un Tuple. Esta función genera código eficiente utilizando el método de Horner si x es real, o utilizando un algoritmo similar a Goertzel ^[DK62] si x es complejo.

Ejemplos

julia> evalpoly(2, (1, 2, 3))
17

@evalpoly(z, c...)

Evalúa el polinomio $\sum_k z^{k-1} c[k]$ para los coeficientes c[1], c[2], ...; es decir, los coeficientes se dan en orden ascendente por potencia de z. Este macro se expande a código en línea eficiente que utiliza ya sea el método de Horner o, para z complejos, un algoritmo más eficiente similar al de Goertzel.

Véase también evalpoly.

Ejemplos

julia> @evalpoly(3, 1, 0, 1)
10

julia> @evalpoly(2, 1, 0, 1)
5

julia> @evalpoly(2, 1, 1, 1)
7

@fastmath expr

Ejecuta una versión transformada de la expresión, que llama a funciones que pueden violar las semánticas estrictas de IEEE. Esto permite la operación más rápida posible, pero los resultados son indefinidos; ten cuidado al hacer esto, ya que puede cambiar los resultados numéricos.

Esto establece las banderas de Fast-Math de LLVM, y corresponde a la opción -ffast-math en clang. Consulta las notas sobre anotaciones de rendimiento para más detalles.

Ejemplos

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672