numbers.adoc

숫자(Numbers)

1. 정수(Integers)

클로저에서 정수는 자기 자신으로 평가되는 값(value)이다. 즉, 아래에서 정수 17을 평가하면 그 결과는 자기 자신인 17이 된다.

17   ;=> 17

type 함수를 이용하면, 해당 값이 어떤 자료형으로 구현되어 있는지를 직접 확인해 볼 수 있다.

(type 17)   ;=> java.lang.Long

위의 결과에서도 알 수 있듯이, 클로저에서 정수형은 자바의 '기본(primitive) 자료형 long' 타입을 내부적으로 감싸고 있는 wrapper class인 java.lang.Long 클래스의 인스턴스이다.

Caution

자바의 기본(primitive) 자료형인 long형이 아니라, 레퍼런스(reference) 타입인 java.lang.Long형임에 주의하자. 레퍼런스 타입이므로 컬렉션 자료형의 요소로 쓰일 수 있다.

Note	클로저에서는 정수 연산의 속도를 높이기 위한 방법으로, 기본 자료형인 long형도 다룰 수 있는 방법을 제공한다. 이에 대해서는 Numerics and Mathematics 장에서 자세히 다룬다.

정수 맨앞에 숫자 0이 있으면 8진수를 표시하고, 0x 또는 0X가 있으면 16진수를 표시한다.

010    ;=> 8

0x10   ;=> 16
0X10   ;=> 16

클로저는 8진수와 16진수 이외에도, 2진수에서 36진수까지 표기할 수 있는 방법을 제공한다. r 또는 R 문자^[1] 앞에 표현하고자 하는 진법을 나타내고, 그 뒤에 숫자를 표시하면 된다. 실제 숫자를 표시할 때, 0 — 9를 넘어가는 숫자는 알파벳 a — z 또는 A — Z 문자를 이용한다.

Note	2 ~ 36진수까지의 표현은 java.lang.Long.parseLong을 이용한다.

;; 2진법
2r1111   ;=> 15

;; 3진법
3r11     ;=> 4

;; 8진법
8r11     ;=> 9

;; 16진법
16rFF    ;=> 255

;; 36진법
36r1z    ;=> 71

정수의 맨 뒤에 대문자 N^[2]을 붙이면, Long형보다 큰 임의의 길이의 정수(arbitrary-precision integer)도 표현할 수 있다.

99999999999999999999N   ;=> 99999999999999999999N

다음의 2N은 java.lang.Long형이 아니라, clojure.lang.BigInt형이다.

2N          ;=> 2N

(type 2N)   ;=> clojure.lang.BigInt

Long형보다 큰 정수에 명시적으로 N을 붙이지 않아도, clojure.lang.BigInt형으로 자동 형변환된다.

 99999999999999999999   ;=> 99999999999999999999N

자동 승격 연산자(+', -', *', inc', and dec')들은 Long 계산이 오버플로우가 발생하면 자동으로 BigInt로 변환해 준다.

(+ 1 Long/MAX_VALUE)
;>> java.lang.ArithmeticException: integer overflow

(+' 1 Long/MAX_VALUE)
;=> 9223372036854775808N

(class (+' 1 Long/MAX_VALUE))
;=> clojure.lang.BigInt

(class (+' 1))
;=> java.lang.Long

bigint 함수는 BigInt를 만든다.

(bigint 1))     ;=> 1N

biginteger 함수는 java.math.BigInteger를 만든다.

(biginteger 1)          ;=> 1
(type (biginteger 1))   ;=> java.math.BigInteger

2. 실수(Floats)

클로저에서 부동 소수점 실수 역시 자기 자신으로 평가되는 값(value)이다. 클로저에서 실수형은 자바의 '기본(primitive) 자료형 double' 타입을 내부적으로 감싸고 있는 wrapper class인 java.lang.Double 클래스의 인스턴스이다.

Note	클로저에서는 실수 연산의 속도를 높이기 위한 방법으로, 기본 자료형인 double형도 다룰 수 있는 방법을 제공한다. 이에 대해서는 Numerics and Mathematics 장에서 자세히 다룬다.

3.14          ;=> 3.14

(type 3.14)   ;=> java.lang.Double

과학적 표기법(Scientific Notation)도 지원한다.

6.0221412927e23   ;=> 6.0221412927E23

실수 뒤에 대문자 M^[3]을 붙이면, 정확도가 보장되는 임의의 길이의 실수(arbitrary-precision signed floating point decimal)를 표현할 수 있다.

100.01M           ;=> 100.01M

(type 100.01M)    ;=> java.math.BigDecimal

(* 100.01M 100)   ;=> 10001.00M

decimal? 함수는 주어진 숫자가 BigDecimal형인지 판별한다.

(decimal? 0.1M)   ;=> true

(decimal? 0.1)    ;=> false
(decimal? 1)      ;=> false

bigdec 함수는 BigDecimal을 만든다.

(bigdec 3.0)    ;=> 3.0M

3. 분수 (Ratios)

클로저에서는 분수 자료형도 제공한다. 분자와 분모 사이에 슬래시(/) 기호를 사용해 표현한다. 이때 분자, 분모와 슬래시 기호 사이에는 공백이 없어야 한다.

1/3          ;=> 1/3
7/4          ;=> 7/4

(type 2/3)   ;=> clojure.lang.Ratio

ratio? 함수는 주어진 숫자가 clojure.lang.Ratio형인지를 판별한다.

(ratio? 4/7)   ;=> true
(ratio? 7)     ;=> false

약분이 가능한 경우에는, 약분된 값이 반환된다.

2/4   ;=> 1/2

분자와 분모는 모두 정수형이어야 한다. 그렇지 않으면 예외가 발생한다.

2/3.5
;>> NumberFormatException Invalid number: 2/3.5

denominator 함수와 numerator 함수는 인수로 주어진 분수의 분자와 분모 부분만을 반환한다.

(numerator 2/3)     ;=> 2
(numerator 2/4)     ;=> 1

(denominator 2/3)   ;=> 3

분수가 포함된 계산의 경우에도 정확한 연산이 보장된다.

(+ 1/3 2/3)   ;=> 1N
(* 1/10 10)   ;=> 1N
(+ 1/3 1)     ;=> 4/3

분수와 실수 사이의 연산 결과는 실수형이다.

(+ 1/3 1.0)   ;=> 1.3333333333333333

분수를 실수로 강제로 형변환하고 싶을 때에는 double이나 float 함수를 사용한다.

(double 1/3)   ;=> 0.3333333333333333
(float 1/3)    ;=> 0.33333334

rational? 함수는 유리수인지를 판별한다. 즉, 정수나 분수이면 true를 반환하고, 그렇지 않으면 false를 반환한다.

Tip	클로저에서 분수형은 내부적으로 분자와 분모가 정수형으로 구현되어 있다. 따라서 내부적인 구현이 정수형으로 이루어진 모든 자료형의 경우, rational? 함수는 true를 반환한다고 생각하면 된다.

(rational? 1/2)   ;=> true
(rational? 1)     ;=> true
(rational? 2N)    ;=> true

(rational? 1.0)   ;=> false

rationalize 함수는 주어진 숫자를 유리수(rational number), 즉 정수나 분수로 변환한다. 무리수가 인수로 주어진 경우에는 가장 근접한 분수로 변환한다.

(rationalize 1.5)   ;=> 3/2
(rationalize 2/4)   ;=> 1/2
(rationalize 4/2)   ;=> 2
(rationalize 2)     ;=> 2
(rationalize 2.0)   ;=> 2N

(rationalize Math/PI)         ;=> 3141592653589793/1000000000000000
(rationalize (Math/sqrt 2))   ;=> 14142135623730951/10000000000000000

4. 산술 연산 함수

숫자 자료형을 모두 다루었으니 이제 산술 연산 함수들을 소개한다. 그에 앞서, 숫자들의 종류에 관계 없이 숫자인지의 여부를 판별해주는 함수 number?가 있다.

(number? 1)      ;=> true
(number? 1.0)    ;=> true
(number? 1/3)    ;=> true

(number? 23N)    ;=> true
(number? 0.1M)   ;=> true

(number? :a)     ;=> false
(number? nil)    ;=> false
(number? "23")   ;=> false

사칙 연산 함수부터 다루어 보자. 이 함수들은 숫자의 자료형에 관계 없이 동작한다.

(+ 1 2)       ;=> 3
(+ 3.5 4.1)   ;=> 7.6
(+ 1/3 1/4)   ;=> 7/12

(- 10 5)      ;=> 5

(* 7 8)       ;=> 56

(/ 6 3)       ;=> 2
(/ 3 4)       ;=> 3/4
(/ 3 4.0)     ;=> 0.75

2개 이상의 인수도 올 수 있다.

(+ 1 2 3 4 5)   ;=> 15
(- 10 9 8 7)    ;=> -14
(* 1 2 3 4 5)   ;=> 120
(/ 20 2 5)      ;=> 2

인수가 하나도 없으면, + 함수는 덧셈의 힝등원 0을, * 함수는 곱셈의 항등원 1을 반환한다.

(+)   ;=> 0
(*)   ;=> 1

-와 / 함수의 경우는, 인수가 하나도 없으면 예외가 발생한다.

(-)   ;>> ArityException Wrong number of args (0) passed to: core/-
(/)   ;>> ArityException Wrong number of args (0) passed to: core//

인수가 한 개만 있는 경우, +와 * 함수는 주어진 인수를 그대로 반환하지만, - 함수는 덧셈의 역원을, / 함수는 곱셈의 역원을 반환한다.

(+ 5)   ;=> 5
(* 9)   ;=> 9

(- 3)   ;=> -3
(/ 3)   ;=> 1/3

몫(quotient)과 나머지(remainder)를 구하려면, 각각 quot와 rem 함수를 이용한다. 이 두 함수는 실수에도 적용된다.

(quot 10 3)      ;=> 3
(rem 10 3)       ;=> 1

(quot 3.7 1.1)   ;=> 3.0
(rem 3.7 1.1)    ;=> 0.3999999999999999

inc와 dec 함수는 1씩 증가 또는 감소 시킨다.

(inc 10)     ;=> 11
(inc 10.1)   ;=> 11.1
(inc 1/2)    ;=> 3/2

(dec 10)     ;=> 9
(dec 10.1)   ;=> 9.1
(dec 1/2)    ;=> -1/2

max과 min 함수는 각각 주어진 인수들 중 최대값과 최소값을 반환한다.

(max 1 2 3 4 5)       ;=> 5
(min 1 2 3 4 5)       ;=> 1

(max 1.1 2 3 4 5.5)   ;=> 5.5
(min 1.1 2 3 4 5.5)   ;=> 1.1

`min-key`와 `max-key`는 주어진 인수들에 함수를 적용해서 나온 최대값과 최소값을 반환한다.

(min-key #(Math/abs %) -3 1 4)          ;=> 1
(apply min-key #(Math/abs %) [-3 1 4])  ;=> 1

(max-key #(Math/abs %) -3 1 4)          ;=> 4
(apply max-key #(Math/abs %) [-3 1 4])  ;=> 4

기타 수학 함수는 java.lang.Math 클래스의 정적(static) 메소드를 이용해야 한다.

Math/PI         ;=> 3.141592653589793
Math/E          ;=> 2.718281828459045

(Math/sqrt 2)   ;=> 1.4142135623730951

(Math/sin (/ Math/PI 2))   ;=> 1.0
(Math/cos 0)               ;=> 1.0

5. 등가/대소 비교 함수

숫자들의 등가를 비교할 떄에는 = 함수보다는 == 함수를 사용하는 것이 바람직하다. = 함수는 숫자들이 인수로 올 경우 숫자들의 타입까지 같아야 true를 반환하기 때문이다.

(= 1 1.0)         ;=> false
(= 0.5 1/2)       ;=> false

(= 1.0 1.0 1.0)   ;=> true
(= 2 2 2)         ;=> true

반면에 == 함수는 타입이 같지 않아도 수학적으로 등가이면 true를 반환한다.

(== 1 1.0)         ;=> true
(== 0.5 1/2)       ;=> true

(== 1.0 1.0 1.0)   ;=> true
(== 2 2 2)         ;=> true

그리고 == 함수는 인자들이 반드시 숫자형이어야만 한다. 그렇지 않으면 예외가 발생한다. 따라서 == 함수는 숫자 전용 등가 비교 함수로 기억하면 된다.

(== :a :a)
;>> ClassCastException clojure.lang.Keyword cannot be cast to java.lang.Number

반면에, = 함수는 숫자 이외의 자료형을 비교하는 데 주로 사용된다.

(= :a :a)         ;=> true
(= "cat" "cat")   ;=> true
(= [2 3] [2 3])   ;=> true

대소 비교 함수에는 <, <=, >, >=가 있다.

(< 10 15)    ;=> true
(<= 10 10)   ;=> true

이 함수들은 2개 이상의 인수들이 올 수 있다. 예를 들어 (< a b c d)와 같은 식이 있으면, 이는 수학적으로 a < b < c < d를 모두 만족해야 true를 반환한다.

(< 1 2 3 4 5)     ;=> true
(< 1 2 3 3 5)     ;=> false

(<= 1 2 3 3 5)    ;=> true

6. 비트 연산

(bit-and 2r1100 2r1001)   ;=> 8
(bit-or  2r1100 2r1001)   ;=> 13
(bit-xor 2r1100 2r1001)   ;=> 5

7. 기타 유용한 함수들

zero? 함수는 0인지를 판별한다.

(zero? 0)     ;=> true
(zero? 0.0)   ;=> true

(zero? 1)     ;=> false
(zero? -1)    ;=> false

(zero? 1.0)   ;=> false
(zero? 1/2)   ;=> false

pos? 함수와 neg? 함수는, 각각 양수인지 음수인지를 판별한다.

(pos? 1)     ;=> true
(pos? 1.0)   ;=> true
(pos? 1/2)   ;=> true

(pos? 0)     ;=> false
(pos? -1)    ;=> false

(neg? -1)     ;=> true
(neg? -1.0)   ;=> true
(pos? -1/2)   ;=> true

(neg? 0)     ;=> false
(neg? 1)     ;=> false

odd? 함수와 even? 함수는, 각각 홀수인지 짝수인지를 판별한다. 인수가 정수가 아니면 예외가 발생한다.

(odd? 1)    ;=> true
(odd? 2)    ;=> false
(odd? 0)    ;=> false

(even? 2)   ;=> true
(even? 1)   ;=>false

(odd? 1.0)
;>> IllegalArgumentException Argument must be an integer: 1.0

---

1. radix의 r을 의미한다.

2. iNteger의 N을 의미한다.

3. 원래는 deciMal의 M에서 비롯된 것이나, Money의 M으로 이해하는 사람도 있다. 이 자료형은 정확한 돈 계산이 필요할 때 주로 사용되기 때문이다.