2016년 8월 1일 월요일

Julia 연습 3

In [ ]:
#
# 나는 julia 를 사랑하는가.
#
In [ ]:
#
# Integer, Floating-Point Number
# 정수, 부동소수점수를 알아보자.
#
In [1]:
1
Out[1]:
1
In [2]:
1234
Out[2]:
1234
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]:
64
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]:
2
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]:
3
In [42]:
2x^2 - 3x + 1
Out[42]:
10
In [45]:
1.5x^2 - .5x + 1
Out[45]:
13.0
In [46]:
2^2x
Out[46]:
64
In [47]:
2(x-1)^2 - 3(x-1) + 1
Out[47]:
3
In [48]:
# 수학식처럼 곱하기를 생략할 수 있다.

(x - 1)x
Out[48]:
6
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]:
8
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]:
12
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]:
1
In [56]:
one(BigFloat)
Out[56]:
1.000000000000000000000000000000000000000000000000000000000000000000000000000000
In [ ]:
시간:
라벨:

Firefly Algorithms

firefly algorithm 001 Firefly Algorithms ¶ 반딧불 알고리즘 번역 요약 ¶ References [1] X. S. Y...

  • groovy 연습 1
    // 그루비를 배워보자. /* 주석이 되나. */ // 그래. 이것이 그루비 코드다. // 2015-02-12 11:34:45 (목요일) println( "Hello world" ) printl...
  • Firefly Algorithms
    firefly algorithm 001 Firefly Algorithms ¶ 반딧불 알고리즘 번역 요약 ¶ References [1] X. S. Y...
  • Julia 연습 1
    In [8]: # # 나는 julia 를 사랑하는가. # In [9]: # 주석. # 이것이 주석이다. # 한줄 주석이다. ...