clojure-基本语法-数字类型

[b][color=red]一、算术运算[/color][/b]
[color=red]加法+：[/color]
加法函数(+)接受任意数值类型的参数，返回它们的和；没有参数时返回0。

user=> (+)
0
user=> (+ 1)
1
user=> (+ 1 2 3 4)
10

[color=red]减法-：[/color]
减法函数(-)接受任意数值类型的参数。如果只有一个参数，则返回它相反的数。当有多个参数时，返回第一个参数减去后面所有参数的结果。

user=> (- 1)
-1
user=> (- 10 2)
8
user=> (- 10 2 3 4)
1

[color=red]乘法*：[/color]
乘法函数 (*) 接受任意数值类型的参数并返回它们的乘积，如果只有一个参数，返回1。

user=> (*)
1
user=> (* 1)
1
user=> (* 1 2 3)
6
user=> (* 0 1 2 3)
0

[color=red]除法/：[/color]
除法函数 (/) 接受任意数值类型的参数。第一个参数是分子，其他任意参数是分母。如果没有分母，则函数返回 1 / 分子，否则返回分子除以分母。

user=> (/ 2)
1/2
user=> (/ 2 10)
1/5
user=> (/ 1 2 4 6)
1/48

[color=red]商quot：[/color]
商函数 (quot) 接受两个数值类型参数并返回第一个参数除以第二个参数的整数商。

user=> (quot 10 3)
3
user=> (quot 11 3)
3
user=> (quot 12 3)
4
user=> (quot -5.9 3)
-1.0
user=> (quot 10 -3)
-3
user=> (quot 15 0)
ArithmeticException / by zero  clojure.lang.Numbers.quotient (Numbers.java:1764)

注意：商函数quot与/函数不是等价的

user=> (= (/ 4 2) (quot 4 2))
true
user=> (= (/ 3 2) (quot 3 2))
false

[color=red]取余rem：[/color]
余数函数 (rem) 接受两个数值类型参数并返回第一个参数除以第二个参数的余数。

user=> (rem 10 9)
1
user=> (rem 2 2)
0
user=> (rem 10 -3)
1

[color=red]取模mod：[/color]
取模函数（mod）接收两个数值类型参数，如果两个参数为正整数或者同为负整数，则与rem函数返回值一致；如果其中有一个负数，则结果为rem返回值与第二个参数之和。比较绕口……

user=> (mod 10 9)
1
user=> (mod 2 2)
0
user=> (mod 10 -3)
-2

[color=red](rem 10 -3)和(mod 10 -3)结果不一致，分别为1，-2。-2是如何得到的？由于（rem 10 -3）的返回值为1，那么（mod 10 -3）的返回值为(+ 1 (rem 10 -3))=-2[/color]
贴上mod函数源码，仅供参考。

(defn mod
  "Modulus of num and div. Truncates toward negative infinity."
  {:added "1.0"
   :static true}
  [num div] 
  (let [m (rem num div)] 
    (if (or (zero? m) (= (pos? num) (pos? div)))
      m 
      (+ m div))))

[color=red]增量函数inc：[/color]
函数 (inc) 接受一个数值类型参数并返回它的值加1。

user=> (inc 1)
2
user=> (inc -1)
0

[color=red]减量函数 (dec)：[/color]
减量函数 (dec) 接受一个数值类型参数并返回它的值减1。

user=> (dec 1)
0
user=> (dec -1)
-2

[color=red]最大函数max：[/color]
最大数函数 (max) 接受任意数值类型的参数并返回最大的。

user=> (max 5 -1 2 3)
5

[color=red]最小函数min：[/color]
最小数函数 (min) 接受任意数值类型的参数并返回最小的。

user=> (min 5 -1 2 3.9)
-1

[color=red]精度函数with-precision：[/color]
精度函数with-precision针对大数据值操作的精度、小数点运算函数。

user=> (with-precision 10 (/ 1M 3))
0.3333333333M
user=> (with-precision 2 (/ 100M 3))
33M
user=> (with-precision 4 (/ 100M 3))
33.33M

[b][color=red]二、比较运算：[/color][/b]
[color=red]值相等=：[/color]
值相等(=)函数接受若干参数，比较若干参数值是否相等。一个参数时，返回true。参数可以为nil。与java中的equals一致。

user=> (= 1)
true
user=> (= 1 1)
true
user=> (= 1 1.0)
false
user=> (= 1 2)
false
user=> (= 1 1 1)
true
user=> (= 1 1 2)
false
user=> (= nil nil)
true

[color=red]等价值==：[/color]
等价值函数接受若干参数，比较若干参数值是否等价。一个参数时，返回true。参数可以为nil、keyword等

user=> (== 1 1.0)
true
user=> (== :foo)
true
user=> (== nil)
true

[color=red]值不同函数not=：[/color]
等价于(not (= obj1 obj2))

user=> (not= 1 1)
false
user=> (not= 1 2)
true
user=> (not= 1 1.0)
true
user=> (not= true true)
false
user=> (not= true false)
true
user=> (not= true true false)
true

[color=red]小于 (<) [/color]
小于函数 (<) 接受任意数值类型的参数，如果它们按升序排列返回true，否则返回false。

user=> (< 5 10)
true
user=> (< 5 10 9)
false
user=> (< 1)
true

[color=red]大于 (>) [/color]
大于函数 (>) 接受任意数值类型的参数，如果它们按降序排列返回true，否则返回false。

user=> (> 5 2)
true
user=> (> 5 10 9)
false
user=> (> 1)
true

[color=red]大于等于 (>=)[/color]
大于等于函数 (>=) 接受任意数值类型的参数，如果它们按降序排列或顺序相等返回true，否则返回false。

user=> (>= 10 5 5)
true

[color=red]小于等于 (<=)[/color]
小于等于函数 (<=) 接受任意数值类型的参数，如果它们按升序排列或顺序相等返回true，否则返回false。

user=> (<= 2 5 5)
true

[b][color=red]三、验证函数：[/color][/b]
[color=red]0检查zero?：[/color]
0检查函数 (zero?) 接受一个数值类型参数，如果是0返回true，否则返回false

user=> (zero? 0.0)
true

[color=red]正数检查pos?： [/color]
正数检查函数 (pos?) 接受一个数值类型参数，如果是大于0返回true，否则返回false

user=> (pos? -2)
false
user=> (pos? 1.2)
true

[color=red]负数检查neg?：[/color]
负数检查函数 (neg?) 接受一个数值类型参数，如果是小于0返回true，否则返回false

user=> (neg? -3)
true
user=> (neg? 0)
false

[color=red]偶数检查even?：[/color]

user=> (even? 10)
true
user=> (even? 3)
false

[color=red]奇数检查odd?：[/color]

user=> (odd? 10)
false
user=> (odd? 3)
true

[color=red]数值检查number?：[/color]
数值检查函数 (number?) 接受一个参数，如果是数值返回true，否则返回false

user=> (number? 3.2)
true
user=> (number? "2")
false

[b][color=red]四、强制转换：[/color][/b]
强制转换支持以下类型：

byte  Coerce to byte. 
short  Coerce to short. 
int  Coerce to int. 
long  Coerce to long. 
float  Coerce to float. 
double  Coerce to double. 
bigint  Coerce to BigInteger. 
bigdec  Coerce to BigDecimal. 
num  Coerce to Number. 
rationalize  returns the rational value of num 

user=> (double 12)
12.0
user=> (short 10000)
10000
user=> (short 22.2)
22
user=> (int 22.2)
22
user=> (long 22.2)
22
user=> (float 100)
100.0
user=> (bigint 1000000000)
1000000000N
user=> (bigdec 100000)
100000M
user=> (num 1.11)
1.11
user=> (rationalize 0.5)
1/2