In [ ]:

#
# 나는 julia 를 사랑하는가.
#

In [ ]:

#
# Integer, Floating-Point Number
# 정수, 부동소수점수를 알아보자.
#

In [1]:

Out[1]:

In [2]:

Out[2]:

In [3]:

# 기본 정수타입은 
# target system 이 32 비트인가, 64 비트인가에 따라 달라진다.

typeof(1)

Out[3]:

Int64

In [4]:

# julia 내부변수에 WORD_SIZE 가 있다.
# 이것이 target system 이 32 비트인가, 64 bit 인가를 알려준다.

WORD_SIZE

Out[4]:

In [6]:

Int

Out[6]:

Int64

In [7]:

UInt

Out[7]:

UInt64

In [8]:

typeof(300000000000)

Out[8]:

Int64

In [23]:

# 16 진수

0x1

Out[23]:

0x01

In [24]:

typeof(ans) # ans 는 바로 직전에 계산된 값이다.

Out[24]:

UInt8

In [11]:

0x123456789

Out[11]:

0x0000000123456789

In [12]:

typeof(ans)

Out[12]:

UInt64

In [14]:

# binary literal

0b10

Out[14]:

0x02

In [15]:

typeof(ans)

Out[15]:

UInt8

In [16]:

# octal literal

0o10

Out[16]:

0x08

In [17]:

typeof(ans)

Out[17]:

UInt8

In [18]:

# 최대 최소값은 
# typemin() 과 typemax() 함수로 표현가능하다.

(typemin(Int32), typemax(Int32))

Out[18]:

(-2147483648,2147483647)

In [21]:

for T in [Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128]
    println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")
end

   Int8: [-128,127]
  Int16: [-32768,32767]
  Int32: [-2147483648,2147483647]
  Int64: [-9223372036854775808,9223372036854775807]
 Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
  UInt8: [0,255]
 UInt16: [0,65535]
 UInt32: [0,4294967295]
 UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

In [25]:

x = typemax(Int64)

Out[25]:

9223372036854775807

In [26]:

# Overflow 가 일어났을때.
# 표현가능한 최대값을 넘어설때, 이런일이 일어난다.

x + 1

Out[26]:

-9223372036854775808

In [28]:

x + 1 == typemin(Int64)

Out[28]:

true

In [29]:

# 부동소수점수

1.0

Out[29]:

1.0

In [30]:

1.

Out[30]:

1.0

In [31]:

0.5

Out[31]:

0.5

In [32]:

.5

Out[32]:

0.5

In [33]:

-1.23

Out[33]:

-1.23

In [34]:

1e10

Out[34]:

1.0e10

In [35]:

2.5e-4

Out[35]:

0.00025

In [38]:

# 위 표현은 모두 Float64 이다.
# Float32 를 표현할때는, e 대신 f 를 쓴다.


0.5f0

Out[38]:

0.5f0

In [39]:

typeof(ans)

Out[39]:

Float32

In [40]:

# 값을 Float32 로 변환.

Float32(-1.5)

Out[40]:

-1.5f0

In [41]:

typeof(ans)

Out[41]:

Float32

In [42]:

# 16진 부동소수점수

0x1p0

Out[42]:

1.0

In [43]:

0x1.8p3

Out[43]:

12.0

In [44]:

typeof(ans)

Out[44]:

Float64

In [45]:

# 반정도 부동소수점수

sizeof(Float16(4.))

Out[45]:

In [46]:

# 반정도 부동소수점수는
# 계산할때는 Float32 로 변환된다.

2*Float16(4.)

Out[46]:

8.0f0

In [47]:

#
# 밑줄문자를 자릿수 구분자로 사용할 수 있다.
#
# 반가운일이다.
# 아름다운 일이다.
#

10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010

Out[47]:

(10000,5.0e-9,0xdeadbeef,0xb2)

In [48]:

# 부동소수점수는 영(0, zero)이 두개다.
# 양의 영, 음의 영.

# 값은 같다.

0.0 == -0.0

Out[48]:

true

In [49]:

# 그러나 바이너리 표현은 다르다.

bits(0.0)

Out[49]:

"0000000000000000000000000000000000000000000000000000000000000000"

In [51]:

bits(-0.0)

Out[51]:

"1000000000000000000000000000000000000000000000000000000000000000"

In [52]:

# infinity
# 무한대

Inf

Out[52]:

Inf

In [54]:

# not a number
# 숫자가 아닌.

NaN

Out[54]:

NaN

In [55]:

1/Inf

Out[55]:

0.0

In [56]:

1/0

Out[56]:

Inf

In [57]:

-5/0

Out[57]:

-Inf

In [58]:

0.000001/0

Out[58]:

Inf

In [59]:

0/0

Out[59]:

NaN

In [1]:

500 + Inf

Out[1]:

Inf

In [2]:

500 - Inf

Out[2]:

-Inf

In [3]:

Inf + Inf

Out[3]:

Inf

In [4]:

Inf - Inf

Out[4]:

NaN

In [5]:

Inf * Inf

Out[5]:

Inf

In [6]:

Inf / Inf

Out[6]:

NaN

In [7]:

0 * Inf

Out[7]:

NaN

In [8]:

#
# 무한에도 16, 32, 64 가 있다.
#

(typemin(Float16), typemax(Float16))

Out[8]:

(-Inf16,Inf16)

In [9]:

(typemin(Float32), typemax(Float32))

Out[9]:

(-Inf32,Inf32)

In [10]:

(typemin(Float64), typemax(Float64))

Out[10]:

(-Inf,Inf)

In [11]:

# machine epsilon
# 표현가능한 부동소수점간의 거리.
# 표현가능한 부동소수점의 해상도.

# julia 는 eps() 함수를 제공한다.

eps(Float32)

Out[11]:

1.1920929f-7

In [12]:

eps(Float64)

Out[12]:

2.220446049250313e-16

In [13]:

eps()

Out[13]:

2.220446049250313e-16

In [14]:

eps(1.0)

Out[14]:

2.220446049250313e-16

In [15]:

eps(1000.)

Out[15]:

1.1368683772161603e-13

In [16]:

eps(1e-27)

Out[16]:

1.793662034335766e-43

In [17]:

eps(0.0)

Out[17]:

5.0e-324

In [18]:

x = 1.25f0

Out[18]:

1.25f0

In [19]:

nextfloat(x)

Out[19]:

1.2500001f0

In [20]:

prevfloat(x)

Out[20]:

1.2499999f0

In [21]:

# 비트의 모양을 한번 보자.

bits( prevfloat(x))

Out[21]:

"00111111100111111111111111111111"

In [22]:

bits(x)

Out[22]:

"00111111101000000000000000000000"

In [23]:

bits( nextfloat(x))

Out[23]:

"00111111101000000000000000000001"

In [24]:

# 반올림


1.1 + 0.1

Out[24]:

1.2000000000000002

In [25]:

# 반올림하는 방법이 IEEE 754 표준에 정의되어있다.
# 
# 그 방법을 지정할 수 있다.

with_rounding(Float64, RoundDown) do
    1.1 + 0.1
end

Out[25]:

1.2

In [26]:

BigInt( typemax(Int64)) + 1

Out[26]:

9223372036854775808

In [27]:

parse( BigInt, "123456789012345678901234567890") + 1

Out[27]:

123456789012345678901234567891

In [28]:

parse( BigFloat, "1.23456789012345678901")

Out[28]:

1.234567890123456789010000000000000000000000000000000000000000000000000000000004

In [29]:

BigFloat( 2.0^66) / 3

Out[29]:

2.459565876494606882133333333333333333333333333333333333333333333333333333333344e+19

In [30]:

factorial( BigInt(40))

Out[30]:

815915283247897734345611269596115894272000000000

In [31]:

# 큰수를 계산하려면 명시적으로 BigInt, BigFloat 로 바꿔줘야한다.

x = typemin(Int64)

Out[31]:

-9223372036854775808

In [32]:

# 여기서 잘못된 값이 발생한다.

x = x - 1

Out[32]:

9223372036854775807

In [33]:

typeof(x)

Out[33]:

Int64

In [34]:

y = BigInt( typemin(Int64))

Out[34]:

-9223372036854775808

In [35]:

# 여기서 제대로 된 값이 발생한다.

y = y - 1

Out[35]:

-9223372036854775809

In [36]:

typeof(y)

Out[36]:

BigInt

In [37]:

# 이 언어는 수치계산의 정확도에 상당한 신경을 쓰고있다.
# 
# set_bigfloat_precision()
# set_rounding()
# with_bigfloat_precision()
# with_rounding()

with_rounding( BigFloat, RoundUp) do
    BigFloat(1) + parse(BigFloat, "0.1")
end

Out[37]:

1.100000000000000000000000000000000000000000000000000000000000000000000000000003

In [39]:

with_rounding( BigFloat, RoundDown) do
    BigFloat(1) + parse(BigFloat, "0.1")
end

Out[39]:

1.099999999999999999999999999999999999999999999999999999999999999999999999999986

In [40]:

with_bigfloat_precision(40) do
    BigFloat(1) + parse(BigFloat, "0.1")
end

Out[40]:

1.1000000000004

In [41]:

x = 3

Out[41]:

In [42]:

2x^2 - 3x + 1

Out[42]:

In [45]:

1.5x^2 - .5x + 1

Out[45]:

13.0

In [46]:

2^2x

Out[46]:

In [47]:

2(x-1)^2 - 3(x-1) + 1

Out[47]:

In [48]:

# 수학식처럼 곱하기를 생략할 수 있다.

(x - 1)x

Out[48]:

In [49]:

# 이것은 안된다.

(x-1)(x+1)

LoadError: MethodError: `call` has no method matching call(::Int64, ::Int64)
Closest candidates are:
  BoundsError()
  BoundsError(!Matched::Any...)
  DivideError()
  ...
while loading In[49], in expression starting on line 1

In [50]:

# 이렇게 해야한다.

(x-1)*(x+1)

Out[50]:

In [51]:

# 이것도 안된다.

x(x+1)

LoadError: MethodError: `call` has no method matching call(::Int64, ::Int64)
Closest candidates are:
  BoundsError()
  BoundsError(!Matched::Any...)
  DivideError()
  ...
while loading In[51], in expression starting on line 1

In [52]:

# 이렇게 해야한다.

x*(x+1)

Out[52]:

In [53]:

# zero(), one() 함수를 제공한다.

zero(Float32)

Out[53]:

0.0f0

In [54]:

zero(1.0)

Out[54]:

0.0

In [55]:

one(Int32)

Out[55]:

In [56]:

one(BigFloat)

Out[56]:

1.000000000000000000000000000000000000000000000000000000000000000000000000000000

In [ ]:

기록 보관소 CODE

2016년 8월 1일 월요일

Julia 연습 3

Firefly Algorithms