本文仅仅介绍 LaTeX3 的整数模块.
构建赋值、运算
首先，利用以下函数创建一个整数变量
1
2
| \int_new:N \l_my_int
\int_new:c {l_my_int}
|
这样就创建了一个整数变量,下面我们来为其赋值：
1
2
3
| \int_set:Nn \l_my_int {10}
\int_set:Nn \l_my_int {2+2*3}
\int_gset:Nn \l_my_int {2+2*3+(2+1)*3}
|
1
2
| \int_set_eq:NN \l_my_int_b \l_my_int_a
\int_gset_eq:NN \l_my_int_b \l_my_int_a
|
使用整数
1
2
| \int_use:N \l_my_int
\int_use:c {...}
|
加(减)一个数
1
2
3
4
5
|
\int_add:Nn \l_my_int {10}
\int_use:N \l_my_int
\int_sub:Nn \l_my_int {1+9}
\int_use:c {l_my_int}
|
自加(减) 1
1
2
| \int_incr:N \l_my_int
\int_decr:N \l_my_int
|
运算
一些数学函数
1
2
3
4
5
6
7
8
| \int_sign:n {100}
\int_abs:n {-10}
\int_div_round:nn {3}{1+1}
\int_div_truncate:nn {3}{2}
\int_max:nn {100}{45}
\int_min:nn {100}{45}
\int_mod:nn {9}{5}
\int_zero:N \l_my_int
|
测试、比较
测试变量是否存在
1
2
| \int_if_exist_p:N \l_my_int
\int_if_exist:NTF \l_my_int {yes} {no}
|
比较
1
2
3
4
| \int_compare_p:nNn {100} > {102}
\int_compare:nNnTF {100} > {102} {yes} {no}
\int_compare_p:n {1<2<3}
\int_compare:nTF {1<2<3} {yes} {no}
|
以上除了 >, <, 还有 =, !=, >= and <= .
case
1
2
3
4
5
6
| \int_case:nn{10}
{
{2+4}{aaa}
{3+7}{bbb}
}
\int_case:nnTF ...
|
测试奇偶
1
2
3
4
| \int_if_even_p:n {...}
\int_if_even:nTF {...} {...} {...}
\int_if_odd_p:n {...}
\int_if_odd:nTF {...} {...} {...}
|
循环
do-until 循环
1
| \int_do_until:nNnn {<intexpr1>} <relation> {<intexpr2>} {<code>}
|
这是 do-until 循环， 它会先执行一次 <code> 中的内容，然后循环，直到条件为真.
示例
1
2
3
4
5
6
7
8
9
| \int_new:N \l_mya_int
\int_new:N \l_myb_int
\int_set:Nn \l_mya_int {1}
\int_set:Nn \l_myb_int {10}
\int_do_until:nNnn {\l_mya_int}>{\l_myb_int}
{
this~is~\int_use:c{l_mya_int}.
\int_incr:N \l_mya_int \par
}
|
这将会输出
示例
1
2
3
4
5
6
7
8
9
| \int_new:N \l_mya_int
\int_new:N \l_myb_int
\int_set:Nn \l_mya_int {1}
\int_set:Nn \l_myb_int {10}
\int_do_until:nNnn {\l_mya_int}<{\l_myb_int}
{
this~is~\int_use:c{l_mya_int}.
\int_incr:N \l_mya_int \par
}
|
这将只得到 this is 1. 对比一下.
do-while 循环
1
| \int_do_while:nNnn {<intexpr1>} <relation> {<intexpr2>} {<code>}
|
与 do-until 循环类似，不过它是等到条件为假时结束循环
示例
1
2
3
4
5
6
7
8
9
| \int_new:N \l_mya_int
\int_new:N \l_myb_int
\int_set:Nn \l_mya_int {1}
\int_set:Nn \l_myb_int {10}
\int_do_while:nNnn {\l_mya_int}<{\l_myb_int}
{
this~is~\int_use:c{l_mya_int}.
\int_incr:N \l_mya_int \par
}
|
这将会输出
类似的还有 until-do , while-do 循环，它们是直接测试条件，不会事先执行一次 <code> 中的内容.
1
2
3
4
5
6
7
8
9
10
11
| \int_until_do:nNnn {⟨intexpr1⟩} ⟨relation⟩ {⟨intexpr2⟩} {⟨code⟩}
\int_while_do:nNnn {⟨intexpr1⟩} ⟨relation⟩ {⟨intexpr2⟩} {⟨code⟩}
\int_do_until:nn {⟨integer relation⟩} {⟨code⟩}
\int_do_while:nn {⟨integer relation⟩} {⟨code⟩}
\int_until_do:nn {⟨integer relation⟩} {⟨code⟩}
\int_while_do:nn {⟨integer relation⟩} {⟨code⟩}
|
自行测试.
step (按步)循环
1
| \int_step_function:nN {⟨final value⟩} ⟨function⟩
|
这个函数是接受 nN 变体，第一个接受一个整数，第二个接受一个函数，也即将整数作为参数传递给该函数.
示例
1
2
| \cs_set:Nn \l_my_cmd:n {I~am~#1~years~old.\par }
\int_step_function:nN {6} \l_my_cmd:n
|
这将会得到
1
2
| \cs_set:Nn \l_my_cmd:n {I~am~#1~years~old.\par }
\int_step_function:nnN {5}{8} \l_my_cmd:n
|
1
2
| \cs_set:Nn \l_my_cmd:n {I~am~#1~years~old.\par }
\int_step_function:nnnN {1}{2}{9} \l_my_cmd:n
|
以上是按函数循环，下面还有两种循环
1
| \int_step_inline:nn{5}{我有~#1~个苹果 \par}
|
得到
这是用 #1 作为参数传递给后面的内容，另外还有：
1
2
3
4
5
6
7
| \int_step_inline:nnn{3}{7}{我有~#1~个苹果 \par}
\int_step_inline:nnnn{3}{2}{9}{我有~#1~个苹果 \par}
\int_step_variable:nNn ...
\int_step_variable:nnNn ...
\int_step_variable:nnnNn ...
|
自行测试一下.
转换
1
2
3
| \int_to_arabic:n{123}
\int_to_alph:n{3}
\int_to_Alph:n{4}
|
1
2
3
4
5
6
7
8
9
10
| \cs_new:Npn \int_to_alph:n #1
{
\int_to_symbols:nnn {#1} { 26 }
{
{ 1 } { a }
{ 2 } { b }
...
{ 26 } { z }
}
}
|
1
2
3
4
5
6
7
| \int_to_bin:n{6}
\int_to_hex:n{78}
\int_to_Hex:n{78}
\int_to_oct:n{10}
\int_to_base:nn{9}{3}
\int_to_base:nn{9}{4}
\int_to_Base:nn{17}{18}
|
1
2
| \int_to_roman:n {2}
\int_to_Roman:n {2}
|
1
2
3
4
5
6
| \int_from_alph:n {f}
\int_from_bin:n ...
\int_from_hex:n ...
\int_from_oct:n ...
\int_from_roman:n ...
\int_from_base:nn ...
|
伪随机数
1
2
| \int_rand:n {10}
\int_rand:nn {5}{8}
|
已定义的常量
1
2
3
4
5
| \c_zero_int
\c_one_int
\c_max_int
\c_max_register_int
\c_max_char_int
|
就到这儿吧，整数模块就告一段落了.