`
songry
  • 浏览: 84568 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

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))))

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

 

1
1
分享到:
评论

相关推荐

    clojure_api_cn:Clojure API 文档的中文翻译版

    关于这是 Clojure 官方 API 文档的中文翻译版本。在线阅读地址: 。翻译进度模块进度译者clojure.core进行中 , ,clojure.data无 clojure.inspector无 clojure.java.browse已完成clojure.java.io已完成clojure.java...

    sparkplug:适用于Apache Spark的Clojure API绑定

    Clojure Spark API SparkPlug是的Clojure API。 安装 库版本在Clojars上发布。 要将最新版本与Leiningen一起使用,请在您的项目中添加以下依赖项: 这将引入omnibus程序包,而该程序包又取决于相同版本的每个子...

    clojure1.6 API英文版

    clojure1.6.0的API文档,英文版

    Clojure学习教程.pdf

    此外,Clojure提供了基本的数学操作符,如加法(+)、减法(-)、乘法(*)和除法(/)。例如,`(+ 1 1)` 将返回 `2`,`(* 1 2)` 将返回 `2`。 列表和向量: 列表(list)是Clojure中的基本数据结构,用于表示有序...

    clj-osf:clj-osf Clojure API 是一个可供 Clojure 开发人员使用的框架,可帮助他们生成对任何 OSF Web 服务端点的查询

    clj-osf clj-osf是一种简单的 Clojure 域特定语言 (DSL),用于查询...文档用法如何使用 API 使用这个 API 真的很简单。 开发人员必须: 在他们的项目中使用 clj-osf 包声明他们想要使用的命名空间通过调用 defosf 和

    clojure相关书籍1

    【1】[Clojure编程乐趣](The Joy of Clojure).pdf 【2】Clojure – Functional Programming for the JVM中文版.pdf 【3】Clojure Cookbook.pdf 【4】Clojure Data Analysis Cookbook.pdf 【5】clojure Hand book...

    Clojure电子书合集1(12本)

    [2009] Programming Clojure.(Stuart Halloway).[1934356336].pdf [2010] Functional Programming with Clojure - Simple Concurrency on the JVM.(Tim Berglund, Matthew McCullough).[193650202X].pdf [2010] ...

    clojure电子书

    《Clojure电子书》集合包含了三本关于Clojure编程的重要书籍和一个Leiningen的Windows安装程序,这对于学习和深入理解Clojure语言至关重要。Clojure是一种基于Lisp的函数式编程语言,它运行在Java虚拟机(JVM)上,...

    Clojure学习——使用clojure jdbc操作mysql

    标题 "Clojure学习——使用clojure jdbc操作mysql" 指出的是一个关于使用Clojure编程语言通过Java Database Connectivity (JDBC) API来操作MySQL数据库的主题。Clojure是一种基于Lisp的函数式编程语言,它运行在Java...

    Clojure Handbook(2012.11.1)

    Clojure Handbook是一份关于Clojure编程语言的学习笔记,旨在为读者提供一个方便的备查材料,以加深对Clojure语言特性的理解和记忆。 首先,Clojure作为Lisp语言家族的一员,具有一些独特的特性。Lisp语言以其极简...

    clojure-twitter, 面向 Twitter API的Clojure客户端.zip

    clojure-twitter, 面向 Twitter API的Clojure客户端 面向Clojure的 Twitter 客户端 API从Clojure访问 Twitter API 。建筑lein depslein jar示例(require 'twitter ['oauth.

    Clojure Data Analysis Cookbook

    1. **基础篇**:这一部分将引导读者入门 Clojure 编程语言的基本概念和语法,为后续深入学习打下坚实的基础。 - **Clojure 入门**:介绍 Clojure 的安装过程、REPL(Read-Eval-Print Loop)环境的使用方法以及简单...

    programming-clojure-3rd

    在Clojure中,Java interoperability(Java互操作性)是一个重要特性,书里会讲解如何无缝地与Java库和API交互,利用JVM的强大生态。同时,Clojure的REPL(Read-Eval-Print Loop)环境也是其一大特色,它促进了快速...

    Practical Clojure.pdf

    作者在开始学习Clojure时,体会到了编程的乐趣,这种感觉只有在初次接触计算机并执行命令时才曾经有过。Clojure语言让程序员能够直接与程序沟通,无需经过模糊的间接层次,使得程序员感觉自己真正控制了程序。 ...

    Clojure编程乐趣]+clojure_programming.pdf

    在“Clojure编程乐趣”这本书中,你将学习到如何使用Clojure进行函数式编程,如何利用Clojure的强大工具处理数据,以及如何构建并发和分布式系统。此外,书中可能还会介绍Clojure社区的一些最佳实践和常用库,例如...

    clojure1.3.0及资料

    1. **《Programming Clojure》**:这本书由Stuart Halloway和Aaron Bedra编写,是Clojure编程的经典教材之一。它全面介绍了Clojure的基础知识,包括数据结构、控制流、函数式编程概念、元编程以及与Java的交互。...

Global site tag (gtag.js) - Google Analytics