Numbers

Número

Supertipo abstracto para todos los tipos de números.

Real <: Number

Supertipo abstracto para todos los números reales.

AbstractFloat <: Real

Supertipo abstracto para todos los números de punto flotante.

Integer <: Real

Supertipo abstracto para todos los enteros (por ejemplo, Signed, Unsigned y Bool).

Véase también isinteger, trunc, div.

Ejemplos

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

Supertipo abstracto para todos los enteros con signo.

Unsigned <: Integer

Supertipo abstracto para todos los enteros sin signo.

Los enteros sin signo incorporados se imprimen en hexadecimal, con el prefijo 0x, y se pueden ingresar de la misma manera.

Ejemplos

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

Tipo de número que representa un valor irracional exacto, que se redondea automáticamente a la precisión correcta en operaciones aritméticas con otras cantidades numéricas.

Los subtipos MyIrrational <: AbstractIrrational deben implementar al menos ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), y convert(::Type{F}, x::MyIrrational) donde {F <: Union{BigFloat,Float32,Float64}}.

Si un subtipo se utiliza para representar valores que pueden ser ocasionalmente racionales (por ejemplo, un tipo de raíz cuadrada que representa √n para enteros n dará un resultado racional cuando n es un cuadrado perfecto), entonces también debe implementar isinteger, iszero, isone, y == con valores Real (ya que todos estos predeterminan a false para tipos AbstractIrrational), así como definir hash para que sea igual al correspondiente Rational.

Float16 <: AbstractFloat <: Real

Tipo de número de punto flotante de 16 bits (estándar IEEE 754). El formato binario es 1 signo, 5 exponentes, 10 bits de fracción.

Float32 <: AbstractFloat <: Real

Tipo de número de punto flotante de 32 bits (estándar IEEE 754). El formato binario es 1 signo, 8 exponentes, 23 bits de fracción.

El exponente para la notación científica debe ingresarse como f en minúscula, así 2f3 === 2.0f0 * 10^3 === Float32(2_000). Para literales de arreglos y comprensiones, el tipo de elemento se puede especificar antes de los corchetes: Float32[1,4,9] == Float32[i^2 for i in 1:3].

Véase también Inf32, NaN32, Float16, exponent, frexp.

Float64 <: AbstractFloat <: Real

Tipo de número de punto flotante de 64 bits (estándar IEEE 754). El formato binario es 1 signo, 11 exponentes, 52 bits de fracción. Consulte bitstring, signbit, exponent, frexp y significand para acceder a varios bits.

Este es el valor predeterminado para literales de punto flotante, 1.0 isa Float64, y para muchas operaciones como 1/2, 2pi, log(2), range(0,90,length=4). A diferencia de los enteros, este valor predeterminado no cambia con Sys.WORD_SIZE.

El exponente para la notación científica se puede ingresar como e o E, por lo tanto 2e3 === 2.0E3 === 2.0 * 10^3. Hacerlo se prefiere fuertemente sobre 10^n porque los enteros desbordarán, por lo tanto 2.0 * 10^19 < 0 pero 2e19 > 0.

Consulte también Inf, NaN, floatmax, Float32, Complex.

BigFloat <: AbstractFloat

Tipo de número de punto flotante de precisión arbitraria.

Bool <: Integer

Tipo booleano, que contiene los valores true y false.

Bool es una especie de número: false es numéricamente igual a 0 y true es numéricamente igual a 1. Además, false actúa como un "cero fuerte" multiplicativo contra NaN y Inf:

julia> [true, false] == [1, 0]
true

julia> 42.0 + true
43.0

julia> 0 .* (NaN, Inf, -Inf)
(NaN, NaN, NaN)

julia> false .* (NaN, Inf, -Inf)
(0.0, 0.0, -0.0)

Las ramas a través de if y otros condicionales solo aceptan Bool. No hay valores "verdaderos" en Julia.

Las comparaciones típicamente devuelven Bool, y las comparaciones transmitidas pueden devolver BitArray en lugar de un Array{Bool}.

julia> [1 2 3 4 5] .< pi
1×5 BitMatrix:
 1  1  1  0  0

julia> map(>(pi), [1 2 3 4 5])
1×5 Matrix{Bool}:
 0  0  0  1  1

Ver también trues, falses, ifelse.

Int8 <: Signed <: Integer

Tipo de entero con signo de 8 bits.

Representa números n ∈ -128:127. Tenga en cuenta que tales enteros desbordarán sin advertencia, por lo tanto typemax(Int8) + Int8(1) < 0.

Véase también Int, widen, BigInt.

UInt8 <: Unsigned <: Integer

Tipo de entero sin signo de 8 bits.

Impreso en hexadecimal, por lo tanto 0x07 == 7.

Int16 <: Signed <: Integer

Tipo de entero con signo de 16 bits.

Representa números n ∈ -32768:32767. Tenga en cuenta que tales enteros se desbordan sin advertencia, por lo tanto typemax(Int16) + Int16(1) < 0.

Véase también Int, widen, BigInt.

UInt16 <: Unsigned <: Integer

Tipo de entero sin signo de 16 bits.

Impreso en hexadecimal, por lo tanto 0x000f == 15.

Int32 <: Signed <: Integer

Tipo de entero con signo de 32 bits.

Tenga en cuenta que tales enteros se desbordan sin advertencia, por lo tanto typemax(Int32) + Int32(1) < 0.

Véase también Int, widen, BigInt.

UInt32 <: Unsigned <: Integer

Tipo de entero sin signo de 32 bits.

Impreso en hexadecimal, por lo tanto 0x0000001f == 31.

Int64 <: Signed <: Integer

Tipo de entero con signo de 64 bits.

Tenga en cuenta que tales enteros se desbordan sin advertencia, por lo tanto typemax(Int64) + Int64(1) < 0.

Véase también Int, widen, BigInt.

UInt64 <: Unsigned <: Integer

Tipo de entero sin signo de 64 bits.

Impreso en hexadecimal, por lo tanto 0x000000000000003f == 63.

Int128 <: Signed <: Integer

Tipo de entero con signo de 128 bits.

Tenga en cuenta que tales enteros se desbordan sin advertencia, por lo tanto typemax(Int128) + Int128(1) < 0.

Véase también Int, widen, BigInt.

UInt128 <: Unsigned <: Integer

Tipo de entero sin signo de 128 bits.

Impreso en hexadecimal, así que 0x0000000000000000000000000000007f == 127.

Int

Tipo de entero con signo de Sys.WORD_SIZE bits, Int <: Signed <: Integer <: Real.

Este es el tipo predeterminado de la mayoría de los literales enteros y es un alias para Int32 o Int64, dependiendo de Sys.WORD_SIZE. Es el tipo devuelto por funciones como length, y el tipo estándar para indexar arreglos.

Tenga en cuenta que los enteros desbordarán sin advertencia, por lo que typemax(Int) + 1 < 0 y 10^19 < 0. El desbordamiento se puede evitar utilizando BigInt. Los literales enteros muy grandes utilizarán un tipo más amplio, por ejemplo, 10_000_000_000_000_000_000 isa Int128.

La división entera es div alias ÷, mientras que / que actúa sobre enteros devuelve Float64.

Véase también Int64, widen, typemax, bitstring.

UInt

Tipo de entero sin signo de Sys.WORD_SIZE bits, UInt <: Unsigned <: Integer.

Al igual que Int, el alias UInt puede apuntar a UInt32 o UInt64, según el valor de Sys.WORD_SIZE en una computadora dada.

Impreso y analizado en hexadecimal: UInt(15) === 0x000000000000000f.

BigInt <: Signed

Tipo de entero de precisión arbitraria.

Complex{T<:Real} <: Número

Tipo de número complejo con parte real e imaginaria de tipo T.

ComplexF16, ComplexF32 y ComplexF64 son alias para Complex{Float16}, Complex{Float32} y Complex{Float64} respectivamente.

Ver también: Real, complex, real.

Racional{T<:Entero} <: Real

Tipo de número racional, con numerador y denominador de tipo T. Se verifica el desbordamiento en los racionales.

Irrational{sym} <: AbstractIrrational

Tipo de número que representa un valor irracional exacto denotado por el símbolo sym, como π, ℯ y γ.

Ver también AbstractIrrational.

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

Devuelve un array con tipo de elemento T (por defecto Int) de los dígitos de n en la base dada, opcionalmente rellenado con ceros hasta un tamaño especificado. Los dígitos más significativos están en índices más altos, de modo que n == sum(digits[k]*base^(k-1) for k in eachindex(digits)).

Véase también ndigits, digits!, y para la base 2 también bitstring, count_ones.

Ejemplos

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

Llena un arreglo con los dígitos de n en la base dada. Los dígitos más significativos están en índices más altos. Si la longitud del arreglo es insuficiente, se llenan los dígitos menos significativos hasta la longitud del arreglo. Si la longitud del arreglo es excesiva, la porción excedente se llena con ceros.

Ejemplos

julia> digits!([2, 2, 2, 2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

Una cadena que da la representación literal en bits de un tipo primitivo.

Véase también count_ones, count_zeros, digits.

Ejemplos

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(::Type{SimpleColor}, rgb::String)

Un análogo de tryparse(SimpleColor, rgb::String) (ver), que genera un error en lugar de devolver nothing.

parse(::Type{Platform}, triplet::AbstractString)

Analiza un triplete de plataforma en forma de cadena de texto y lo convierte de nuevo en un objeto Platform.

parse(tipo, str; base)

Analiza una cadena como un número. Para los tipos Integer, se puede especificar una base (el valor predeterminado es 10). Para los tipos de punto flotante, la cadena se analiza como un número decimal de punto flotante. Los tipos Complex se analizan a partir de cadenas decimales de la forma "R±Iim" como un Complex(R,I) del tipo solicitado; "i" o "j" también se pueden usar en lugar de "im", y "R" o "Iim" también son permitidos. Si la cadena no contiene un número válido, se genera un error.

Ejemplos

julia> parse(Int, "1234")
1234

julia> parse(Int, "1234", base = 5)
194

julia> parse(Int, "afc", base = 16)
2812

julia> parse(Float64, "1.2e-3")
0.0012

julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
0.32 + 4.5im

tryparse(::Type{SimpleColor}, rgb::String)

Intenta analizar rgb como un SimpleColor. Si rgb comienza con # y tiene una longitud de 7, se convierte en un SimpleColor respaldado por un RGBTuple. Si rgb comienza con a-z, rgb se interpreta como un nombre de color y se convierte en un SimpleColor respaldado por un Symbol.

De lo contrario, se devuelve nothing.

Ejemplos

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

tryparse(tipo, str; base)

Como parse, pero devuelve ya sea un valor del tipo solicitado, o nothing si la cadena no contiene un número válido.

big(x)

Convierte un número a una representación de máxima precisión (típicamente BigInt o BigFloat). Consulta BigFloat para obtener información sobre algunas trampas con los números de punto flotante.

signed(T::Integer)

Convierte un tipo de bit entero a su tipo firmado del mismo tamaño.

Ejemplos

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

Convierte un número a un entero con signo. Si el argumento es sin signo, se reinterpreta como con signo sin verificar el desbordamiento.

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

unsigned(T::Integer)

Convierte un tipo de bit entero al tipo sin signo del mismo tamaño.

Ejemplos

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

Convierte un número o arreglo a un tipo de dato de punto flotante.

Véase también: complex, oftype, convert.

Ejemplos

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

Extrae el significando (también conocido como mantisa) de un número de punto flotante. Si x es un número finito no cero, entonces el resultado será un número del mismo tipo y signo que x, y cuyo valor absoluto está en el intervalo $[1,2)$. De lo contrario, se devuelve x.

Véase también frexp, exponent.

Ejemplos

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

julia> significand(-15.2) * 2^3
-15.2

julia> significand(-Inf), significand(Inf), significand(NaN)
(-Inf, Inf, NaN)

exponent(x::Real) -> Int

Devuelve el mayor entero y tal que 2^y ≤ abs(x).

Lanza un DomainError cuando x es cero, infinito, o NaN. Para cualquier otro número de punto flotante no subnormal x, esto corresponde a los bits del exponente de x.

Véase también signbit, significand, frexp, issubnormal, log2, ldexp.

Ejemplos

julia> exponent(8)
3

julia> exponent(6.5)
2

julia> exponent(-1//4)
-2

julia> exponent(3.142e-4)
-12

julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
(-126, -149)

julia> exponent(0.0)
ERROR: DomainError with 0.0:
Cannot be ±0.0.
[...]

complex(r, [i])

Convierte números reales o arreglos a complejos. i por defecto es cero.

Ejemplos

julia> complex(7)
7 + 0im

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

bswap(n)

Invierte el orden de los bytes de n.

(Véase también ntoh y hton para convertir entre el orden de bytes nativo actual y el orden big-endian.)

Ejemplos

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

hex2bytes(itr)

Dado un iterable itr de códigos ASCII para una secuencia de dígitos hexadecimales, devuelve un Vector{UInt8} de bytes correspondientes a la representación binaria: cada par sucesivo de dígitos hexadecimales en itr da el valor de un byte en el vector de retorno.

La longitud de itr debe ser par, y el array devuelto tiene la mitad de la longitud de itr. Véase también hex2bytes! para una versión en su lugar, y bytes2hex para la inversa.

Ejemplos

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

Convierte un iterable itr de bytes que representan una cadena hexadecimal a su representación binaria, similar a hex2bytes excepto que la salida se escribe en su lugar en dest. La longitud de dest debe ser la mitad de la longitud de itr.

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

Convierte un iterador itr de bytes a su representación en cadena hexadecimal, ya sea devolviendo un String a través de bytes2hex(itr) o escribiendo la cadena en un flujo io a través de bytes2hex(io, itr). Los caracteres hexadecimales son todos en minúsculas.

Ejemplos

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

Devuelve una identidad multiplicativa para x: un valor tal que one(x)*x == x*one(x) == x. Alternativamente, one(T) puede tomar un tipo T, en cuyo caso one devuelve una identidad multiplicativa para cualquier x del tipo T.

Si es posible, one(x) devuelve un valor del mismo tipo que x, y one(T) devuelve un valor del tipo T. Sin embargo, esto puede no ser el caso para tipos que representan cantidades con dimensiones (por ejemplo, tiempo en días), ya que la identidad multiplicativa debe ser adimensional. En ese caso, one(x) debería devolver un valor de identidad de la misma precisión (y forma, para matrices) que x.

Si deseas una cantidad que sea del mismo tipo que x, o del tipo T, incluso si x tiene dimensiones, utiliza oneunit en su lugar.

Consulta también la función identity, y I en LinearAlgebra para la matriz identidad.

Ejemplos

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

oneunit(x::T)
oneunit(T::Type)

Devuelve T(one(x)), donde T es el tipo del argumento o (si se pasa un tipo) el argumento. Esto difiere de one para cantidades con dimensiones: one es adimensional (una identidad multiplicativa) mientras que oneunit es dimensional (del mismo tipo que x, o del tipo T).

Ejemplos

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 día

zero(x)
zero(::Type)

Obtiene el elemento de identidad aditiva para el tipo de x (x también puede especificar el tipo en sí).

Véase también iszero, one, oneunit, oftype.

Ejemplos

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

La unidad imaginaria.

Véase también: imag, angle, complex.

Ejemplos

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

La constante pi.

Unicode π se puede escribir escribiendo \pi y luego presionando tab en el REPL de Julia, y en muchos editores.

Ver también: sinpi, sincospi, deg2rad.

Ejemplos

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

La constante ℯ.

Unicode ℯ se puede escribir escribiendo \euler y presionando tab en el REPL de Julia, y en muchos editores.

Ver también: exp, cis, cispi.

Ejemplos

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

constante de Catalan.

# Ejemplos

jldoctest julia> Base.MathConstants.catalan catalan = 0.9159655941772...

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01 0.9159466120554123 ```

γ
eulergamma

La constante de Euler.

Ejemplos

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133

φ
oro

La proporción áurea.

Ejemplos

julia> Base.MathConstants.golden
φ = 1.6180339887498...

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

Infinito positivo de tipo Float64.

Véase también: isfinite, typemax, NaN, Inf32.

Ejemplos

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf, Inf64

Infinito positivo de tipo Float64.

Véase también: isfinite, typemax, NaN, Inf32.

Ejemplos

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

Infinito positivo de tipo Float32.

Inf16

Infinito positivo del tipo Float16.

NaN, NaN64

Un valor no numérico de tipo Float64.

Véase también: isnan, missing, NaN32, Inf.

Ejemplos

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN, NaN64

Un valor no numérico de tipo Float64.

Véase también: isnan, missing, NaN32, Inf.

Ejemplos

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN32

Un valor no numérico de tipo Float32.

Ver también: NaN.

NaN16

Un valor no numérico de tipo Float16.

Ver también: NaN.

issubnormal(f) -> Bool

Prueba si un número de punto flotante es subnormal.

Un número de punto flotante IEEE es subnormal cuando sus bits de exponente son cero y su significante no es cero.

Ejemplos

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

Prueba si un número es finito.

Ejemplos

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

Prueba si un número es infinito.

Ver también: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

Prueba si un valor numérico es un NaN, un valor indeterminado que no es ni una infinita ni un número finito ("no es un número").

Véase también: iszero, isone, isinf, ismissing.

iszero(x)

Devuelve true si x == zero(x); si x es un array, esto verifica si todos los elementos de x son cero.

Véase también: isone, isinteger, isfinite, isnan.

Ejemplos

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

isone(x)

Devuelve true si x == one(x); si x es un arreglo, esto verifica si x es una matriz identidad.

Ejemplos

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

nextfloat(x::AbstractFloat, n::Integer)

El resultado de n aplicaciones iterativas de nextfloat a x si n >= 0, o -n aplicaciones de prevfloat si n < 0.

nextfloat(x::AbstractFloat)

Devuelve el número de punto flotante más pequeño y del mismo tipo que x tal que x < y. Si no existe tal y (por ejemplo, si x es Inf o NaN), entonces devuelve x.

Véase también: prevfloat, eps, issubnormal.

prevfloat(x::AbstractFloat, n::Integer)

El resultado de n aplicaciones iterativas de prevfloat a x si n >= 0, o -n aplicaciones de nextfloat si n < 0.

prevfloat(x::AbstractFloat)

Devuelve el número de punto flotante más grande y del mismo tipo que x tal que y < x. Si no existe tal y (por ejemplo, si x es -Inf o NaN), entonces devuelve x.

isinteger(x) -> Bool

Prueba si x es numéricamente igual a algún entero.

Ejemplos

julia> isinteger(4.0)
true

isreal(x) -> Bool

Prueba si x o todos sus elementos son numéricamente iguales a algún número real, incluyendo infinitos y NaNs. isreal(x) es verdadero si isequal(x, real(x)) es verdadero.

Ejemplos

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Float32(x [, mode::RoundingMode])

Crea un Float32 a partir de x. Si x no es representable exactamente, entonces mode determina cómo se redondea x.

Ejemplos

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

Consulta RoundingMode para los modos de redondeo disponibles. ```

Float64(x [, mode::RoundingMode])

Crea un Float64 a partir de x. Si x no es representable exactamente, entonces mode determina cómo se redondea x.

Ejemplos

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

Consulta RoundingMode para los modos de redondeo disponibles.

rounding(T)

Obtiene el modo de redondeo de punto flotante actual para el tipo T, controlando el redondeo de las funciones aritméticas básicas (+, -, *, / y sqrt) y la conversión de tipos.

Consulta RoundingMode para los modos disponibles.

setrounding(T, mode)

Establece el modo de redondeo del tipo de punto flotante T, controlando el redondeo de las funciones aritméticas básicas (+, -, *, / y sqrt) y la conversión de tipos. Otras funciones numéricas pueden dar valores incorrectos o inválidos al usar modos de redondeo diferentes del predeterminado RoundNearest.

Tenga en cuenta que esto actualmente solo es compatible con T == BigFloat.

setrounding(f::Function, T, mode)

Cambia el modo de redondeo del tipo de punto flotante T durante la duración de f. Es lógicamente equivalente a:

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

Consulta RoundingMode para los modos de redondeo disponibles.

get_zero_subnormals() -> Bool

Devuelve false si las operaciones en valores de punto flotante subnormales ("denormales") obedecen las reglas de la aritmética IEEE, y true si podrían convertirse en ceros.

set_zero_subnormals(yes::Bool) -> Bool

Si yes es false, las operaciones de punto flotante subsiguientes siguen las reglas de la aritmética IEEE sobre valores subnormales ("denormales"). De lo contrario, se permite (pero no se requiere) que las operaciones de punto flotante conviertan entradas o salidas subnormales a cero. Devuelve true a menos que yes==true pero el hardware no soporte la anulación de números subnormales.

set_zero_subnormals(true) puede acelerar algunos cálculos en cierto hardware. Sin embargo, puede romper identidades como (x-y==0) == (x==y).

count_ones(x::Integer) -> Integer

Número de unos en la representación binaria de x.

Ejemplos

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

Número de ceros en la representación binaria de x.

Ejemplos

julia> count_zeros(Int32(2 ^ 16 - 1))
16

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

Número de ceros que preceden la representación binaria de x.

Ejemplos

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

Número de unos que preceden la representación binaria de x.

Ejemplos

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

trailing_zeros(x::Integer) -> Integer

Número de ceros al final de la representación binaria de x.

Ejemplos

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

Número de unos que siguen a la representación binaria de x.

Ejemplos

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

Devuelve true si x es un entero impar (es decir, un entero no divisible por 2), y false en caso contrario.

Ejemplos

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

Devuelve true si x es un entero par (es decir, un entero divisible por 2), y false en caso contrario.

Ejemplos

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

Analiza str como un Int128. Lanza un ArgumentError si la cadena no es un entero válido.

Ejemplos

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]

@uint128_str str

Analiza str como un UInt128. Lanza un ArgumentError si la cadena no es un entero válido.

Ejemplos

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
[...]

BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

Crea un número de punto flotante de precisión arbitraria a partir de x, con precisión precision. El argumento rounding especifica la dirección en la que el resultado debe ser redondeado si la conversión no se puede realizar exactamente. Si no se proporciona, estos se establecen por los valores globales actuales.

BigFloat(x::Real) es lo mismo que convert(BigFloat,x), excepto si x ya es BigFloat, en cuyo caso devolverá un valor con la precisión establecida en la precisión global actual; convert siempre devolverá x.

BigFloat(x::AbstractString) es idéntico a parse. Esto se proporciona por conveniencia ya que los literales decimales se convierten a Float64 al ser analizados, por lo que BigFloat(2.1) puede no dar lo que esperas.

Véase también:

• @big_str
• rounding y setrounding
• precision y setprecision

Ejemplos

julia> BigFloat(2.1) # 2.1 aquí es un Float64
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # el BigFloat más cercano a 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

Obtiene la precisión de un número de punto flotante, tal como se define por el número efectivo de bits en el significante, o la precisión de un tipo de punto flotante T (su valor predeterminado actual, si T es un tipo de precisión variable como BigFloat).

Si se especifica base, entonces devuelve el número máximo correspondiente de dígitos del significante en esa base.

setprecision([T=BigFloat,] precision::Int; base=2)

Establece la precisión (en bits, por defecto) que se utilizará para la aritmética de T. Si se especifica base, entonces la precisión es la mínima requerida para dar al menos precision dígitos en la base dada.

setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

Cambia la precisión aritmética de T (en la base dada) durante la duración de f. Es lógicamente equivalente a:

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

A menudo se usa como setprecision(T, precision) do ... end

Nota: nextfloat(), prevfloat() no utilizan la precisión mencionada por setprecision.

BigInt(x)

Crea un entero de precisión arbitraria. x puede ser un Int (o cualquier cosa que se pueda convertir a un Int). Los operadores matemáticos habituales están definidos para este tipo, y los resultados se promueven a un BigInt.

Las instancias se pueden construir a partir de cadenas a través de parse, o utilizando el literal de cadena big.

Ejemplos

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

Analiza una cadena en un BigInt o BigFloat, y lanza un ArgumentError si la cadena no es un número válido. Para enteros, se permite _ en la cadena como separador.

Ejemplos

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: formato de número inválido _ para BigInt o BigFloat
[...]