Emacs 折腾日记(五)——elisp 数字类型

本文是参考 emacs lisp 简明教程 写的，很多东西都是照搬里面的内容，如果各位读者觉得本文没有这篇教程优秀或者有抄袭嫌疑、又或者觉得我更新比较慢、再或者其他什么原因，请直接阅读上述链接中的教程。

上一篇我们讲了elisp中的流程控制结构相关的内容，下面就该进入到对应数据结构的学习了。elisp中主要的数据结构有：整数、浮点数、列表、符号、向量、散列表等等类型。下面我们先从最简单的类型——整数和浮点数说起

数字类型

与C/C++对比起来，elisp数字类型少的多，C/C++ 整数类型就有好几种，包括有符号、无符号、int、short、long之类的。elisp不区分这些，它仅仅有整数和浮点数。而且elisp 中只有浮点数这一种小数类型，不像C/C++还有双精度浮点数和单精度浮点数之分。

elisp的整数范围与具体的机器有关，它的范围可以通过变量 most-positive-fixnum 和 most-negative-fixnum 来得到。例如在我的机器上它们的值如下

most-positive-fixnum ;; 2305843009213693951
most-negative-fixnum ;; -2305843009213693952

在给变量使用数字类型赋值的时候，我们可以使用10进制或者其他任意进制的形式。例如

#b101100 => 44      ; 二进制
#o54 => 44          ; 八进制
#x2c => 44          ; 十进制
#24r1k => 44        ; 二十四进制

因为26个英文字母+10个数字的原因，我们最大只能使用36进制来表示一个数字，但是基本不用到这么大的。日常最多也就用用10进制、二进制、16进制、8进制都算用的少。

浮点数的表达遵循 IEEE 标准，也就是可以使用带小数点的数字来表示，或者带上 e 来使用科学计数法，例如

3.14
1.0e-10

数字类型的测试

作为动态类型的语言，在代码执行阶段，变量的类型是会发生变化的。我们无法仅通过变量名或者变量的初始化值来判断变量类型。emacs的变量在执行阶段都知道自己的类型，但是它无法主动向我们报告，我们需要使用一些函数来进行判断，关于数字类型，提供了下列的函数

integerp
floatp
numberp

从字面上能理解它们分别判断是否是整形、浮点数、以及数字类型。

elisp 测试函数一般都是用 p 来结尾，p 是 predicate 的第一个字母。如果函数名是一个单词，通常只是在这个单词后加一个 p，如果是多个单词，一般是加 -p

数的比较

与C/C++ 类似，数字的比较一般有 >、<、>=、<= 。但是也有不同的地方，因为elisp中都是使用 setq 来进行赋值的，所以它采用 = 来表示数学意义上的相等。还有一个不同的地方因为elisp中没有 += 、-=、/= 、*= 这样的运算符，所以它使用 /= 来作为不等的判断符号

与其他语言类似的，浮点数直接使用等于或者不等于来判断并不准确，需要在一定范围内忽略误差。在C/C++中，我们常见的写法是给定一个误差值，然后二者差的绝对值在这个误差值范围内则认为它们相等。我们将这个算法使用elisp改写一下就得到下面的代码

(defun approx-equal (x y)
  (let ((fuzz-factor 1.0e-6))
    (< (abs (- x y)) fuzz-factor)))

(approx-equal 1.000001 1.00000000000000001) ;; => t

上述的写法并不严谨，在一定误差范围内，它是对的，但是在某些情况下它就不对了，例如 1.0e-7 和 1.0e-12 。它们本身并不相等，但是它们都超过了这个误差范围，相减之后的值小于这个误差范围。但是我们看到其实它们直接的差距还是挺大的，间隔1.0e5 的数量积。我们可以将上述算法进行一些改进

(defun approx-equal(x y)
  (let ((fuzz-factor 1.0e-6))
    (or (and (= x 0) (= y 0))
        (< (/ (abs (- x y))
              (max (abs x) (abs y)))
           fuzz-factor))))

(approx-equal 1.0e-7 1.0e-12) ;; => t

这段代码采用的是比较相对差距的办法。因为涉及到除法，所以先把二者等于0的情况排除了，避免发生除0的问题。上述代码改造成对应的C代码就是

#define FUZZ_FACTOR 1.0e-6  // 定义误差范围

bool approx_equal(double x, double y) {
    // 处理特殊情况：如果两个数都是 0
    if (x == 0 && y == 0) {
        return true;
    }

    // 计算相对差并进行比较
    double relative_difference = fabs(x - y) / fmax(fabs(x), fabs(y));
    return relative_difference < FUZZ_FACTOR;
}

另外 elisp 中有 eql 函数来判断两个数是否相等

(eql 1 1.0) ;; => nil
(eql 1.0e-7 1.0e-12) ;; => nil

eql 在判断数字时不光判断值，也判断类型。第一条语句，因为二者类型不同，第二条语句二者都是float属于同类型，但是二者的值不同，因此两个结果都是假。

数字的转换

elisp 中可以进行 整形和float型数字的相互转换。在C/C++ 中，整形可以通过隐式转换自动转换成float，而float转换成int时会丢失小数位，比如哪怕是 1.9 在转换为整数时也会是 1。

在elisp中，可以通过float将整数转化为浮点数。例如

(floatp 1) ; ⇒ nil
(floatp (float 1)) ; ⇒ t
(eql (float 1) 1.0) ; ⇒ t

而浮点数转化成整数有下面几个函数

• truncate: 抹除小数位，也就是C/C++语言中float转int的操作
• floor: 类似于C/C++ 中的floor 函数，返回小于等于该数的最大整数
• ceiling: 类似于 C/C++ 中的 ceil 函数，返回大于等于该数的最小整数
• round: 类似于 C/C++ 中的 round 函数，返回四舍五入后的整数

数的运算

一般的语言，数的运算无外乎 +、-、*、/ 取整、取模。elisp 中同样有这些操作，前面的加减乘除跟其他语言一致，没什么特别的。

C/C++ 以及 elisp 中的除法都不是纯粹数学意义上的除法，它会将结果抹掉小数位转换成整数。我们如果将除数或者被除数转换为float类型的话，那么就得到数学意义上的除法结果 (当然也不全是，毕竟float数据有表达数据的限制)但是python 不一样，它就是纯粹数学意义上的除法。这个设计我也不知道算是好还是不好，毕竟它与其他语言不一致增加了记忆的负担。

(/ 3 2) ; ⇒ 1
(/ (float 3) 2) ; ⇒ 1.5
(/ 3.0 2) ; ⇒ 1.5

C/C++ 中有 ++ 、 -- 操作，而且还分 前++ 和 后++ 。在 elisp 中没有这两个操作，也没有类似于 += 的操作。elisp的赋值一直是用的 setq。而且它提供了 1+ 1- 这两个符号来表示 ++ 和 --。至于是前 ++ 还是 后++ 呢？两个都不是，C/C++中的 ++ 本身具有改变变量值的作用，它们的区别在于是返回值之前改变还是之后改变。而elisp 主要使用 setq 来改变变量的值， 1+ 这个操作无法改变变量的，它仅仅改变这条语句返回的值。例如可以使用下面的代码来测试

(defun inc (num)
	(1+ num))

(setq foo (inc 3)) ;; ⇒ 4

这里将传入的参数加了1，但是其实函数中 num 的值并没有变化，我们可以对函数做一下修改来验证这一点

(defun inc (num)
	(progn
	(1+ num)
	num))

(setq foo (inc 3)) ; ⇒ 3

要改变变量的值需要使用 setq 来进行赋值，这个函数可以做一下修改

(defun inc (num)
	(progn
	(setq num (1+ num))
	num))

(setq foo (inc 3)) ; ⇒ 4

取模的操作，elisp 中提供了两个方式 % 和 mod 函数，其中 % 与其他语言类似，它要求除数与被除数都是整数，而 mod 则没有这个要求。

我们查看mod函数，发现它是被写在C代码里面的。它虽然也是取余，但是它与数学意义上取余的结果并不一致，例如

(mod -10 3) ;; ⇒ 2
(mod 10 -3) ;; => -2
(% -10 3) ;; ⇒ -1
(% 10 -3) ;; ⇒ 1

% 单纯的就是数学意义上的取模的操作，首先找到商，然后根据商来决定模

而 mod 则不同，mod 中首先一个原则就是余数和除数的符号相同。所以第一个的结果应该是正数 也就是 -3 * 4 + 2 = 10，余数是2。第二个结果应该是 - 3 * (-4) - 2 = 10
mod 还有一个原则，那就是商的结果应该是整数。利用这两个原则我们就可以大概的还原一下计算的过程

(mod 3.5 2) ;; ⇒ 1.5
(mod -3.5 2) ;; ⇒ 0.5
(mod 3.5 -2) ;; ⇒ -0.5

根据上面两个原则，那么它们分别可以还原为

• 1 * 2 + 1.5 = 3.5
• -2 * 2 + 0.5 = -3.5
• -2 * (-2) + 0.5 = 3.5

另外还有一些其他数学上的操作，对于学习后面写配置的话，大多数应该是用不到的。后续需要使用的话再查询就好了，这里就不在多啰嗦了。

到此为止我们已经介绍完了elisp中数的常见操作。后续将陆续介绍其他数据类型，敬请期待。