clojure API学习(1) 数学运算

附注：本文基于jdk1.6,clojure1.2

数学运算   

    让我们通过学习clojure的API来一步步了解它，首先是最简单的数学运算。

加法+

    API中对加法函数的描述是：

clojure.core/+
([] [x] [x y] [x y & more])
  Returns the sum of nums. (+) returns 0.

    首先，它位于clojure.core命名空间下，能够接受0到任意数量的参数，如果没有参数，则返回0。下面我们来

实验一下：

user> (+)
0
user> (+ 1)
1
user> (+ 255 1)
256

    很明显，我们都得到了预期的结果。那么，如果是混合的数据类型会如何呢？

user> (+ 1 2r01111111)
128
user> (+ 0x7f 0177)
254

    在上面的例子中，我们采用了十进制数和二进制数相加，16进制数和8进制数相加，最后都得到了预期的结果，

但是要注意，这个结果是十进制数。

    众所周知，在java中，char和int是能够相互转换的，让我们来试试：

user> (+ 1 \a)

    结果抛出异常了：

java.lang.Character cannot be cast to java.lang.Number
  [Thrown class java.lang.ClassCastException]

    原因很明显，clojure中采用的都是java的包装类型而非基础类型，所以在进行加法运算时，就不能像java一样：

int first = 1;
char second = 'a';
System.out.println(first+second);

    这个没有异常，输出值为98。

    由此可见，只要参数不是java.lang.number的子类，那么肯定会抛出类型转换异常，这次我们换用一个字符串

参数来试试，预期会抛出String无法转换成Number的异常：

user> (+ 1 "a")

    果然抛出异常了：

java.lang.String cannot be cast to java.lang.Number
  [Thrown class java.lang.ClassCastException]

    那么，我们换用一个浮点数试试，不管是Double还是Float都是Number的子类，应该不会有异常了：

user> (+ 3.5 2)
5.5

    成功运行，这儿我们注意到，如果采用浮点数，则返回的类型也自动转换为浮点数了。这让我们想到另外的一种

类型--分数，clojure是支持分数的，那么我们采用分数来做加法，能否取得预期的结果呢？

user> (+ 2 2/3)
8/3

    可以相加！那让我们探寻一下更深入的境界，浮点数和分数相加：

user> (+ 2.5 2/3)
3.166666666666667

    这样也可以，注意返回的结果被转换成了浮点数。

    然后我们看看+函数的源代码：

(defn +
  "Returns the sum of nums. (+) returns 0."
  {:inline (fn [x y] `(. clojure.lang.Numbers (add ~x ~y)))
   :inline-arities #{2}
   :added "1.0"}
  ([] 0)
  ([x] (cast Number x))
  ([x y] (. clojure.lang.Numbers (add x y)))
  ([x y & more]
   (reduce + (+ x y) more)))

    在定义的语法(defn +)后首先我们看到的是一段针对函数的说明性文字("Returns the sum of nums.

(+) returns 0.")，然后是元数据结构(花括号包含的那三行)，它包含了内联的匿名函数、内联的参数数量

以及从哪个版本以上开始支持这个函数。最后是函数体的实现。

    很明显，从函数体上来看，这是一个基于参数数量重载的函数，它可以接收从0到任意数量的参数，直到

堆栈溢出。

    ([] 0)代表没有参数时返回0。

    ([x] (cast Number x))说明只有一个参数时，执行表达式(cast Number x)，cast是个函数，这个表达式

的含义是如果x不是Number类型，则抛出类型转换异常，否则返回x。

    ([x y] (. clojure.lang.Numbers (add x y)))是传入两个参数时，执行表达式

(. clojure.lang.Numbers (add x y))，这个表达式的含义是调用java类clojure.lang.Numbers的add方法，

并将x、y作为参数传入add方法，并返回方法的执行结果。（clojure.lang.Numbers一共4528行，如果add

的两个参数类型相同，则直接调用静态方法返回结果；如果两个参数类型不同，则通过内部接口的多个内部实现类

通过combine来定义返回结果的类型，比如：如果是一个Integer和Long相加，则返回的是Long；如果是一个

BigInteger和Long相加，则返回的是一个BigInteger）。

    ([x y & more]
   (reduce + (+ x y) more)))这是在传入参数大于2时，执行(reduce + (+ x y) more))这个表达式。我们可以

看出，这儿出现了一个递归调用。+函数作为reduce函数的参数被调用了，那么reduce函数的作用是什么呢？它

接收两个或者三个参数，第一个参数是一个拥有两个参数的函数，在当前表达式中，就是+函数本身；第二个参数

是可选的，是一个元素，在当前表达式中，就是(+ x y)表达式的返回值，这儿也是个递归调用；第三个参数则是一

个集合，在当前表达式中，就是+函数接收的第三个到最后一个参数的集合。reduce的作用就是将第二个参数和

第三个参数集合中的第一个元素作为参数传给第一个参数函数，在当前的表达式中，就是将(+ x y)求值的结果和

more里头的第一个元素即+函数的第三个参数相加；这个执行结果又将作为参数和集合中的下一个元素一起作为

参数传递给第一个参数函数，以此类推，有点像累加器，最后的结果作为返回值。

    至此，我们可以看出，+函数的主体实现其实就是通过java类clojure.lang.Numbers的add方法进行两个数的

相加，更多数字的相加都是通过对两个数字相加操作的递归调用来实现的。

减法-

    在探寻加法操作时，我们已经发现了，能进行数学操作的都是java.lang.number的子类，那么我们能进行的

减法就很明显了：

user> (- 1 2)
-1
user> (- 3 4.53)
-1.5300000000000002
user> (- 1/2 1/3)
1/6
user> (- 5.5 1/2)
5.0
user> (- 0x54 2r11111111)
-171

   在这当中，我们注意到一个很有趣的现象， (- 3 4.53)这一句的执行结果莫名多了0.0000000000000002出来，

这是怎么回事呢？让我们到java中来看看：

System.out.println(3-4.53);

    结果果然是：

-1.5300000000000002

    这是因为二进制无法精确表达一些十进制浮点数造成的，《java解惑》中对此有精确的描述。clojure在此忠实地

继承了这一特性。如果需要进行浮点数的精确运算，我们需要将参数声明为BigDecimal就能够解决这个问题了：

user> (- 3 (. java.math.BigDecimal valueOf 453e-2))
-1.53M

    我们看到，这样就得到了预期的结果，不过后面这个M是啥玩意？其实，这就是标注这个数字的对象类型是BigDecimal，让我们用class来查看一下就明白了：

user> (class 1.53M)
java.math.BigDecimal
user> (class 1.53)
java.lang.Double

    一目了然，如果没有M后缀，这个数字是Double类型，有了M后缀，这个数字就属于BigDecimal类型了，所以，

之前的例子我们也可以写作：

user> (- 3 4.53M)
-1.53M

    得到了相同的结果。不过，据测试BigDecimal执行运算的性能大约是Double的60-100倍，这个大家自己斟酌吧。

    接下来我们看看-函数的源码：

(defn -
  "If no ys are supplied, returns the negation of x, else subtracts
  the ys from x and returns the result."
  {:inline (fn [& args] `(. clojure.lang.Numbers (minus ~@args)))
   :inline-arities #{1 2}
   :added "1.0"}
  ([x] (. clojure.lang.Numbers (minus x)))
  ([x y] (. clojure.lang.Numbers (minus x y)))
  ([x y & more]
   (reduce - (- x y) more)))

    结构很眼熟，不是吗？最大的差别在于，单参数情况下，-函数返回的是这个参数的负值；而且并不支持无参调用。

乘法*

    有了前面加减法的经验，乘法就没什么惊喜了：

user> (* 3 8)
24
user> (* 5 4/5)
4
user> (* 3.5 9)
31.5
user> (* 5 3 6.5)
97.5

    看看源码：

(defn *
  "Returns the product of nums. (*) returns 1."
  {:inline (fn [x y] `(. clojure.lang.Numbers (multiply ~x ~y)))
   :inline-arities #{2}
   :added "1.0"}
  ([] 1)
  ([x] (cast Number x))
  ([x y] (. clojure.lang.Numbers (multiply x y)))
  ([x y & more]
   (reduce * (* x y) more)))

    跟加法几乎一模一样的结构，不需要任何解说了。

除法/

    除法不一样的地方在于，它能产生分数：

user> (/ 3 2)
3/2
user> (/ 4 2)
2
user> (/ 3.0 2)
1.5
user> (/ 0 3)
0

    如果我们查询分数的类型，会发现这实际上是一个clojure自定的类型：

user> (class 3/3)
java.lang.Integer
user> (class 3/2)
clojure.lang.Ratio

    除法的源码：

(defn /
  "If no denominators are supplied, returns 1/numerator,
  else returns numerator divided by all of the denominators."
  {:inline (fn [x y] `(. clojure.lang.Numbers (divide ~x ~y)))
   :inline-arities #{2}
   :added "1.0"}
  ([x] (/ 1 x))
  ([x y] (. clojure.lang.Numbers (divide x y)))
  ([x y & more]
   (reduce / (/ x y) more)))

    这个结构我们已经看过三次了，已经都很熟悉了。

整除quot

    整除和一般除法不同的地方在于，它不会产生分数和小数，它直接抛弃余数，得到整型的结果：

user> (quot 3 2)
1
user> (quot 3 2.0)
1
user> (class (quot 3 2.0))
java.lang.Integer

    从上面例子我们可以看出，即使我们采用了Double类型的分母2.0，最后得出的结果仍然是整型。

    整除的源码：

(defn quot
  "quot[ient] of dividing numerator by denominator."
  {:added "1.0"}
  [num div]
    (. clojure.lang.Numbers (quotient num div)))

    更加简单，除了调用clojure.lang.Numbers中的quotient方法外，没有其他任何操作。

取余rem

    如同字面意义一样，取余操作就是对两个数相除取余数：

user> (rem 3 2)
1
user> (rem 3 2.0)
1.0
user> (rem 5 1/4)
0
user> (rem 3 2/5)
1/5
user> (rem 4.5 3.5)
1.0

    如上所见，余数有可能是整型、浮点型或者分数。看看源码：

(defn rem
  "remainder of dividing numerator by denominator."
  {:added "1.0"}
  [num div]
    (. clojure.lang.Numbers (remainder num div)))

    很好，没什么内容。

求模mod

    在参数都为正数或者都为负数时，求模和取余得到的结果是一致的，但是如果一个参数为正，一个参数为负时，

mod和rem的结果就不一样了：

user> (mod -7 -2)
-1
user> (rem -7 -2)
-1
user> (mod 7 2)
1
user> (rem 7 2)
1
user> (mod 7 -2)
-1
user> (rem 7 -2)
1
user> (mod -10 3)
2
user> (rem -10 3)
-1

    关于求模和取余的详细操作，大家可以自行百度。源码是：

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

    这个代码很清晰，如果num对div取余的结果为零或者num和div都为正数或者都为负数，就直接返回结果；

否则返回取余结果加上div的值。

加一inc

    inc函数的作用是返回某个数字加一的结果，有点类似于java中的++操作符，但是区别在于，clojure中的数据结构

是不可变的，在执行了inc函数后，原本的值是没有改变的：

user> (def var-a 1)
#'user/var-a
user> (inc var-a)
2
user> var-a
1
user> (inc 2.15)
3.15
user> (inc 2/3)
5/3

    如上所见，在执行了inc函数后，var-a的值依然是1。同时我们也注意到，针对浮点数和分数，inc函数仍然能够

产生作用。源码如下：

(defn inc
  "Returns a number one greater than num."
  {:inline (fn [x] `(. clojure.lang.Numbers (inc ~x)))
   :added "1.0"}
  [x] (. clojure.lang.Numbers (inc x)))

    嗯，又直接交给clojure.lang.Numbers处理了。

减一dec

    dec函数类似于inc函数，只不过它执行的是减一的操作：

user> (dec 2.51)
1.5099999999999998
user> (dec 2/3)
-1/3
user> (dec 50)
49

    在执行浮点数减法时，又出现了我们之前遇到过的精度问题。源码如下：

(defn dec
  "Returns a number one less than num."
  {:inline (fn [x] `(. clojure.lang.Numbers (dec ~x)))
   :added "1.0"}
  [x] (. clojure.lang.Numbers (dec x)))

    毫不意外的，clojure.lang.Numbers类再次大展身手。

取最大值max

    max函数可以接收任意数目的参数，然后返回其中最大值：

user> (max 0x235 2r111111 513 34e5)
3400000.0
user> (max 1 2 3 4 5)
5
user> (max 151/8 20 13)
20
user> (max 151/8 10 13)

    很明显，max的返回类型是跟最大值的类型一致的。源码如下：

(defn max
  "Returns the greatest of the nums."
  {:added "1.0"}
  ([x] x)
  ([x y] (if (> x y) x y))
  ([x y & more]
   (reduce max (max x y) more)))

    嗯，似曾相识的结构，仍然是将多元操作通过递归解析为二元操作。

取最小值min

    min函数类似于max函数，所以我们看看源码就直接跳过吧：

(defn min
  "Returns the least of the nums."
  {:added "1.0"}
  ([x] x)
  ([x y] (if (< x y) x y))
  ([x y & more]
   (reduce min (min x y) more)))

 设置精度with-precision

    with-precision宏是为之前我们提到的BigDecimal运算操作时指定精度的：

user> (with-precision 10 (/ 1M 3))
0.3333333333M
user> (with-precision 6 (/ 2 3M))
0.666667M

    仔细数数小数点后面的位数，就能看到它和with-precision宏的第一个参数是吻合的。

    如果with-precision的第二个参数不是BigDecimal，那么它将不起作用：

user> (with-precision 6 (/ 2 3.0))
0.6666666666666666

    我们看看源码：

(defmacro with-precision
  "Sets the precision and rounding mode to be used for BigDecimal operations.

  Usage: (with-precision 10 (/ 1M 3))
  or:    (with-precision 10 :rounding HALF_DOWN (/ 1M 3))

  The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,
  HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP."
  {:added "1.0"}
  [precision & exprs]
    (let [[body rm] (if (= (first exprs) :rounding)
                      [(next (next exprs))
                       `((. java.math.RoundingMode ~(second exprs)))]
                      [exprs nil])]
      `(binding [*math-context* (java.math.MathContext. ~precision ~@rm)]
         ~@body)))

    这是一个宏的定义，所以要比我们之前看到的函数定义复杂得多，但大体结构仍然相同，首先是定义语法，然后

是说明性文字，然后是元数据，最后是宏的主体。显而易见，宏的主体是最为复杂的部分。

    首先看看参数vector，它包含了两部分，precision和& exprs，precision是精度数字，而& exprs代表任意数量

的表达式参数，实际上，with-precision宏只会返回最后一个表达式的带精度结果，示例如下：

user> (with-precision 6 (/ 1M 3) (/ 2M 3) (/ 4M 3))
1.33333M

    然后我们看到了一个let包裹了下面所有的内容，let是一个特殊form，它的作用就是建立绑定，可以理解为临时变量

，但是跟其他语言的临时变量不同的是，let建立的绑定一旦初始化，就不能再更改绑定的值。在这个地方，let建立的

绑定是个vector--[body rm]，这里面包含了两个符号body和rm，而这两个符号对应的值是表达式：

(if (= (first exprs) :rounding)
                      [(next (next exprs))
                       `((. java.math.RoundingMode ~(second exprs)))]
                      [exprs nil])

    的返回值。我们可以看得出，这个表达式的结构是一个判断语句，如果传入的表达式集合参数exprs的第一个元素是

:rounding关键字，则返回如下vector：

 [(next (next exprs))
                       `((. java.math.RoundingMode ~(second exprs)))]

    这个结果vector的第一个元素是exprs中排除第一、二个元素后剩下的所有元素，这个exprs剩余元素集合将被赋给

body绑定，而结果vector的第二个元素实际上是调用java.math.RoundingMode枚举中的某个常量，这个常量将被

赋给rm绑定，实际上，我们在之前的说明性文字中也可以看到：

 (with-precision 10 :rounding HALF_DOWN (/ 1M 3))

  The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,
  HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.

    在这儿，exprs就是 :rounding HALF_DOWN (/ 1M 3) 这个集合。(first exprs)的结果就是:rounding关键字，

(second exprs)的结果就是HALF_DOWN，前面的~意思是取这个表达式的执行结果而非表达式本身。而

(. java.math.RoundingMode ~(second exprs))等同于java中的java.math.RoundingMode.HALF_DOWN。

这个枚举常量的作用是决定丢弃精度数值操作的舍入模式，详情请见相关API 。而(next (next exprs)对应的就是

exprs剩余的部分(/ 1M 3)。

    而如果exprs的第一个元素不是:rounding关键字，则会直接返回 [exprs nil]这个vector，那么，body绑定的

值就是exprs的所有元素，而rm绑定的值则是空--nil。

    在临时绑定赋值完成之后，开始执行业务代码：

 `(binding [*math-context* (java.math.MathContext. ~precision ~@rm)]
         ~@body)))

    `代表在运行时直接按照字面值展开其后的表达式，而不会进行求值；除非是有~前缀的符号。binding宏和let类似，

同样是先在vector中建立绑定，然后返回下面的表达式。我们先看这个vector：

[*math-context* (java.math.MathContext. ~precision ~@rm)]，它要对*math-context*全局变量进行赋值

，(java.math.MathContext. ~precision ~@rm)这个表达式代表将precision和rm的值作为参数传入

java.math.MathContext的构造函数中返回一个java.math.MathContext对象实例。这个对象实例将被赋给

*math-context*全局变量。绑定赋值结束后，body绑定的值就会作为结果被返回。注意，body绑定的值本身就是一个

表达式集合。

    现在，我们再回头看看这个例子：

(with-precision 10 :rounding HALF_DOWN (/ 1M 3))

    在运行中，首先会根据:rounding和HALF_DOWN生成java.math.RoundingMode.HALF_DOWN枚举常量，然后

将10和java.math.RoundingMode.HALF_DOWN传入java.math.MathContext的构造函数中生成

java.math.MathContext对象实例，然后将这个对象实例赋值给全局变量*math-context*，最后执行(/ 1M 3)

表达式并返回结果。

    然后我们采用macroexpand将with-precision的执行过程展开看看：

user> (macroexpand '(with-precision 10 :rounding HALF_DOWN (/ 1M 3)))
(let* [] 
  (clojure.core/push-thread-bindings 
    (clojure.core/hash-map 
      (var clojure.core/*math-context*) 
      (java.math.MathContext. 10 
        (. java.math.RoundingMode HALF_DOWN))))
  (try  
    (/ 1M 3) 
    (finally (clojure.core/pop-thread-bindings))))

    可以看到，整个执行过程跟上面描述的是一致的。