知っていて当たり前-05　定数，変数，型など

# 知っていて当たり前-05　定数，変数，型など

## 1.　定数

### 1.1.　円周率


```julia
π # または pi
```




    π = 3.1415926535897...




```julia
1π # 単なる π とは違う
```




    3.141592653589793



### 1.2.　ネイピア数


```julia
ℯ # \euler + tab 
```




    ℯ = 2.7182818284590...




```julia
1ℯ # 単なる ℯ とは違う
```




    2.718281828459045



### 1.3.　エプシロン epsilon　実数の精度


```julia
eps()
```




    2.220446049250313e-16




```julia
x = 1;
x == x + eps()
```




    false




```julia
x == x + eps()/2
```




    true



### 1.4.　定数の定義　const 修飾子

定数名は，すべて大文字で書く


```julia
const DEFAULT_VAL = 99999
```




    99999




```julia
const X, Y = 1.2, 3.4
```




    (1.2, 3.4)



## 2.　変数の型

### 2.1.　`isa()`


```julia
isa(1, Int), isa(1.0, Float64), isa(true, Bool), isa(1+2im, Complex)
```




    (true, true, true, true)




```julia
isa("1", String), isa('1', Char)
```




    (true, true)




```julia
isa([1,2,3], Array), isa([1,2,3], Vector), isa([1,2,3], Matrix)
```




    (true, true, false)




```julia
isa([1 2;3 4], Array), isa([1 2;3 4], Vector), isa([1 2;3 4], Matrix)
```




    (true, false, true)



### 2.2.　`typeof()`, `eltype()`


```julia
typeof(1), eltype(1)
```




    (Int64, Int64)




```julia
typeof(1.0), eltype(1.0)
```




    (Float64, Float64)




```julia
typeof("1"), eltype("1")
```




    (String, Char)




```julia
typeof('1'), eltype('1')
```




    (Char, Char)




```julia
typeof(true), eltype(true)
```




    (Bool, Bool)




```julia
V = [1 2 3 4]
typeof(V), eltype(V)
```




    (Matrix{Int64}, Int64)




```julia
M = [1 2; 3.5 4]
typeof(M), eltype(M)
```




    (Matrix{Float64}, Float64)




```julia
a=1//2
typeof(a), eltype(a)
```




    (Rational{Int64}, Rational{Int64})



## 3.　変数の型の変換

### 3.1.　`oftype()`, `convert()`

第2引数の型を第1引数の型にする


```julia
oftype(4.0, 3), convert(typeof(4.0), 3), convert(Float64, 3)
```




    (3.0, 3.0, 3.0)




```julia
oftype(4, 3.0), convert(typeof(4), 3.0), convert(Int64, 3.0)
```




    (3, 3, 3)




```julia
convert(Int64, 1.1) # InexactError: Int64(1.1)
```


### 3.2.　`Array{}()`


```julia
Array{Float64, 1}([1, 2, 3]), Array{Int64, 1}([1.0, 2.0, 3.0])
```




    ([1.0, 2.0, 3.0], [1, 2, 3])




```julia
Array{Int64, 1}([1.1, 2.2, 3.3]) # InexactError: Int64(1.1)
```


### 3.3.　`Int.()`, `float.()`, `string.()`


```julia
x = Array{Any,1}([1, 2, 3])
```




    3-element Vector{Any}:
     1
     2
     3



Array{Any,1} になっているものを Int64, Float64, String に変換


```julia
Int.(x)  # Array{Any,1} になっているものを Int64 に
```




    3-element Vector{Int64}:
     1
     2
     3




```julia
float.(x)  # Array{Any,1} になっているものを Float64 に
```




    3-element Vector{Float64}:
     1.0
     2.0
     3.0




```julia
string.(x) # Array{Any,1} になっているものを String に
```




    3-element Vector{String}:
     "1"
     "2"
     "3"



## 4.　特定の型を持つ 0, 1


```julia
M = [pi, 1.2]
s = zero(eltype(M))
```




    0.0




```julia
typeof(s)
```




    Float64




```julia
a = 1//10
s = one(eltype(a))
```




    1//1




```julia
typeof(s)
```




    Rational{Int64}



## 5.　変数の型ごとの最大値と最小値


```julia
typemax(Int64), typemin(Int64)
```




    (9223372036854775807, -9223372036854775808)




```julia
typemax(UInt64), typemin(UInt64)
```




    (0xffffffffffffffff, 0x0000000000000000)




```julia
typemax(Float64), typemin(Float64)
```




    (Inf, -Inf)



## 6.　数の表現法

### 6.1.　分数　rational number


```julia
2//3
```




    2//3




```julia
numerator(2//3), denominator(2//3) # 分子，分母
```




    (2, 3)




```julia
float(3//4) # 実数化
```




    0.75




```julia
5//0, float(5//0), typeof(-3//0)
```




    (1//0, Inf, Rational{Int64})




```julia
Rational(2.64) # 分数化
```




    5944751508129055//2251799813685248



### 6.2.　長精度整数


```julia
big(21), typeof(big(21)), factorial(big(21))
```




    (21, BigInt, 51090942171709440000)



### 6.3.　長精度実数


```julia
big(21.0), typeof(big(21.0))
```




    (21.0, BigFloat)




```julia
big(1.123) # 誤差のある実数を長精度実数にするので結果も誤差が大きい
```




    1.1229999999999999982236431605997495353221893310546875




```julia
big"1.123" # 長精度実数の正しい指定法
```




    1.122999999999999999999999999999999999999999999999999999999999999999999999999999



#### 6.3.1.　精度（仮想のビット数）


```julia
precision(BigFloat), precision(Float64)
```




    (256, 53)



#### 6.3.2.　精度の設定


```julia
setprecision(BigFloat, 1000)
```




    1000




```julia
precision(BigFloat)
```




    1000




```julia
sqrt(big(8))^2
```




    7.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999925



## 7.　2 進数，8 進数，16 進数


```julia
a = 0b111 # 2 進数
b = 0o12  # 8 進数
c = 0x120 # 16 進数
a, b, c
```




    (0x07, 0x0a, 0x0120)




```julia
Int(a), Int(b), Int(c) # 10 進数に変換
```




    (7, 10, 288)




```julia
string(a) # 文字列に変換（10 進数）
```




    "7"




```julia
string(a, base=2) # 文字列に変換（2 進数）
```




    "111"




```julia
string(123, base=16), string(-123, base=16) # 文字列に変換（16 進数）
```




    ("7b", "-7b")




```julia
string(-123, base=16, pad=8) # 文字列に変換（16 進数, 0 埋め）
```




    "-0000007b"



## 8.　数値の桁数　`ndigits()`


```julia
ndigits(1234567)
```




    7




```julia
string(1234567), length(string(1234567))
```




    ("1234567", 7)




```julia
ndigits(1234567, base=16)
```




    6




```julia
string(1234567, base=16), length(string(1234567, base=16))
```




    ("12d687", 6)