Number type representing an exact irrational value, which is automatically rounded to the correct precision in arithmetic operations with other numeric quantities.

Subtypes MyIrrational <: AbstractIrrational should implement at least ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), and convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}.

If a subtype is used to represent values that may occasionally be rational (e.g. a square-root type that represents √n for integers n will give a rational result when n is a perfect square), then it should also implement isinteger, iszero, isone, and == with Real values (since all of these default to false for AbstractIrrational types), as well as defining hash to equal that of the corresponding Rational.

source

具象数值类型

Core.Float16 — Type

1. Float16 <: AbstractFloat

16-bit floating point number type (IEEE 754 standard).

Binary format: 1 sign, 5 exponent, 10 fraction bits.

source

Core.Float32 — Type

1. Float32 <: AbstractFloat

32-bit floating point number type (IEEE 754 standard).

Binary format: 1 sign, 8 exponent, 23 fraction bits.

source

Core.Float64 — Type

1. Float64 <: AbstractFloat

64-bit floating point number type (IEEE 754 standard).

Binary format: 1 sign, 11 exponent, 52 fraction bits.

source

Base.MPFR.BigFloat — Type

1. BigFloat <: AbstractFloat

Arbitrary precision floating point number type.

source

Core.Bool — Type

1. Bool <: Integer

Boolean type, containing the values true and false.

Bool is a kind of number: false is numerically equal to 0 and true is numerically equal to 1. Moreover, false acts as a multiplicative “strong zero”:

1. julia> false == 0
2. true

4. julia> true == 1
5. true

7. julia> 0 * NaN
8. NaN

10. julia> false * NaN
11. 0.0

数据格式

Base.digits — Function

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

Return an array with element type T (default Int) of the digits of n in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indices, such that n == sum(digits[k]*base^(k-1) for k=1:length(digits)).

See also ndigits, digits!, and for base 2 also bitstring, count_ones.

Examples

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

6. julia> digits(10, base = 2)
7. 4-element Vector{Int64}:
8. 0
9. 1
10. 0
11. 1

13. julia> digits(-256, base = 10, pad = 5)
14. 5-element Vector{Int64}:
15. -6
16. -5
17. -2
18. 0
19. 0

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

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

source

Base.digits! — Function

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

Fills an array of the digits of n in the given base. More significant digits are at higher indices. If the array length is insufficient, the least significant digits are filled up to the array length. If the array length is excessive, the excess portion is filled with zeros.

Examples

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

8. julia> digits!([2,2,2,2,2,2], 10, base = 2)
9. 6-element Vector{Int64}:
10. 0
11. 1
12. 0
13. 1
14. 0
15. 0

source

Base.bitstring — Function

1. bitstring(n)

A string giving the literal bit representation of a number.

See also count_ones, count_zeros, digits.

Examples

1. julia> bitstring(Int32(4))
2. "00000000000000000000000000000100"

4. julia> bitstring(2.2)
5. "0100000000000001100110011001100110011001100110011001100110011010"

source

Base.parse — Function

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

Parses a string platform triplet back into a Platform object.

source

1. parse(type, str; base)

Parse a string as a number. For Integer types, a base can be specified (the default is 10). For floating-point types, the string is parsed as a decimal floating-point number. Complex types are parsed from decimal strings of the form "R±Iim" as a Complex(R,I) of the requested type; "i" or "j" can also be used instead of "im", and "R" or "Iim" are also permitted. If the string does not contain a valid number, an error is raised.

Julia 1.1

parse(Bool, str) requires at least Julia 1.1.

Examples

1. julia> parse(Int, "1234")
2. 1234

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

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

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

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

source

Base.tryparse — Function

1. tryparse(type, str; base)

Like parse, but returns either a value of the requested type, or nothing if the string does not contain a valid number.

source

Base.big — Function

1. big(x)

Convert a number to a maximum precision representation (typically BigInt or BigFloat). See BigFloat for information about some pitfalls with floating-point numbers.

source

Base.signed — Function

1. signed(T::Integer)

Convert an integer bitstype to the signed type of the same size.

Examples

1. julia> signed(UInt16)
2. Int16
3. julia> signed(UInt64)
4. Int64

source

1. signed(x)

Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as signed without checking for overflow.

常用数值函数和常量

Base.one — Function

1. one(x)
2. one(T::type)

Return a multiplicative identity for x: a value such that one(x)*x == x*one(x) == x. Alternatively one(T) can take a type T, in which case one returns a multiplicative identity for any x of type T.

If possible, one(x) returns a value of the same type as x, and one(T) returns a value of type T. However, this may not be the case for types representing dimensionful quantities (e.g. time in days), since the multiplicative identity must be dimensionless. In that case, one(x) should return an identity value of the same precision (and shape, for matrices) as x.

If you want a quantity that is of the same type as x, or of type T, even if x is dimensionful, use oneunit instead.

See also the identity function, and I in LinearAlgebra for the identity matrix.

Examples

1. julia> one(3.7)
2. 1.0

4. julia> one(Int)
5. 1

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

source

Base.oneunit — Function

1. oneunit(x::T)
2. oneunit(T::Type)

Returns T(one(x)), where T is either the type of the argument or (if a type is passed) the argument. This differs from one for dimensionful quantities: one is dimensionless (a multiplicative identity) while oneunit is dimensionful (of the same type as x, or of type T).

Examples

1. julia> oneunit(3.7)
2. 1.0

4. julia> import Dates; oneunit(Dates.Day)
5. 1 day

source

Base.zero — Function

1. zero(x)
2. zero(::Type)

Get the additive identity element for the type of x (x can also specify the type itself).

整型

Base.count_ones — Function

1. count_ones(x::Integer) -> Integer

Number of ones in the binary representation of x.

Examples

1. julia> count_ones(7)
2. 3

4. julia> count_ones(Int32(-1))
5. 32

source

Base.count_zeros — Function

1. count_zeros(x::Integer) -> Integer

Number of zeros in the binary representation of x.

Examples

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

4. julia> count_zeros(-1)
5. 0

source

Base.leading_zeros — Function

1. leading_zeros(x::Integer) -> Integer

Number of zeros leading the binary representation of x.

Examples

1. julia> leading_zeros(Int32(1))
2. 31

source

Base.leading_ones — Function

1. leading_ones(x::Integer) -> Integer

Number of ones leading the binary representation of x.

Examples

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

source

Base.trailing_zeros — Function

1. trailing_zeros(x::Integer) -> Integer

Number of zeros trailing the binary representation of x.

Examples

1. julia> trailing_zeros(2)
2. 1

source

Base.trailing_ones — Function

1. trailing_ones(x::Integer) -> Integer

Number of ones trailing the binary representation of x.

Examples

1. julia> trailing_ones(3)
2. 2

source

Base.isodd — Function

1. isodd(x::Number) -> Bool

Return true if x is an odd integer (that is, an integer not divisible by 2), and false otherwise.

Julia 1.7

Non-Integer arguments require Julia 1.7 or later.

Examples

1. julia> isodd(9)
2. true

4. julia> isodd(10)
5. false

source

Base.iseven — Function

1. iseven(x::Number) -> Bool

Return true if x is an even integer (that is, an integer divisible by 2), and false otherwise.

Julia 1.7

Non-Integer arguments require Julia 1.7 or later.

Examples

1. julia> iseven(9)
2. false

4. julia> iseven(10)
5. true

source

Core.@int128_str — Macro

1. @int128_str str
2. @int128_str(str)

@int128_str parses a string into a Int128 Throws an ArgumentError if the string is not a valid integer

source

Core.@uint128_str — Macro

1. @uint128_str str
2. @uint128_str(str)

@uint128_str parses a string into a UInt128 Throws an ArgumentError if the string is not a valid integer

source

BigFloats and BigInts

The BigFloat and BigInt types implements arbitrary-precision floating point and integer arithmetic, respectively. For BigFloat the GNU MPFR library is used, and for BigInt the GNU Multiple Precision Arithmetic Library (GMP) is used.

Base.MPFR.BigFloat — Method

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

Create an arbitrary precision floating point number from x, with precision precision. The rounding argument specifies the direction in which the result should be rounded if the conversion cannot be done exactly. If not provided, these are set by the current global values.

BigFloat(x::Real) is the same as convert(BigFloat,x), except if x itself is already BigFloat, in which case it will return a value with the precision set to the current global precision; convert will always return x.

BigFloat(x::AbstractString) is identical to parse. This is provided for convenience since decimal literals are converted to Float64 when parsed, so BigFloat(2.1) may not yield what you expect.