类 Int

整数（任意精度）

class Int is Cool does Real { }

Int 对象存储任意大小的整数。Int 是不可变的。

Int 文字有两种主要语法形式

123;         # Int in decimal notation 
:16<BEEF>;   # Int in radix notation

为了方便，常见的基数形式带有前缀快捷方式。

say so :2<11111111> == 0b11111111 == :8<377> == 0o377 == 255 == 0d255 == :16<ff> == 0xff;
# OUTPUT: «True␤»

所有形式都允许在任意两个数字之间使用下划线作为视觉分隔符，但不带有任何含义

5_00000;       # five Lakhs 
500_000;       # five hundred thousand 
0xBEEF_CAFE;   # a strange place 
:2<1010_1010>; # 0d170

基数表示法还支持圆括号和方括号，它们允许您解析给定基数的字符串，并将数字组合成一个整数

:16("9F");         # 159 
:100[99, 2, 3];    # 990203

这些表示法也允许您使用变量

my $two = "2";
my $ninety-nine = "99";
:16($ninety-nine); # 153 
:100[99, $two, 3]; # 990203

方法§

方法 new§

multi method new(Any:U $type)
multi method new(Any:D \value --> Int:D)
multi method new(int   \value --> Int:D)

第一种形式将引发异常；第二种和第三种形式将从变量中包含的实际整数值创建新的 Int。

方法 Str§

multi method Str(Int:D)
multi method Str(Int:D, :$superscript)
multi method Str(Int:D, :$subscript)

返回数字的字符串表示形式。

say 42.Str;                # OUTPUT: «42␤»

Cool 是 Int 的父类，因此很少需要显式调用 Int.Str 方法，除非您希望字符串以上角标或下角标返回。

say 42.Str(:superscript); # OUTPUT: «⁴²␤» 
say 42.Str(:subscript);   # OUTPUT: «₄₂␤»

:superscript 和 :subscript 命名参数自 2023.05 Rakudo 编译器版本起可用。

方法 Capture§

method Capture()

引发 X::Cannot::Capture。

例程 chr§

multi        chr(Int:D  --> Str:D)
multi method chr(Int:D: --> Str:D)

通过将整数解释为 Unicode 代码点编号并将其转换为相应字符，返回一个单字符字符串。

示例

65.chr;  # returns "A" 
196.chr; # returns "Ä"

例程 expmod§

multi        expmod(      $x,     $y,     $mod --> Int:D)
multi        expmod(Int:D $x, Int $y, Int $mod --> Int:D)
multi method expmod(Int:D:    Int $y, Int $mod --> Int:D)

返回给定的 Int 在模数 $mod 内提升到 $y 次幂，即给出 ($x ** $y) mod $mod 的结果。子例程形式可以接受非 Int 参数，这些参数将强制转换为 Int。

say expmod(4, 2, 5);    # OUTPUT: «1␤» 
say 7.expmod(2, 5);     # OUTPUT: «4␤»

$y 参数也可以为负数，在这种情况下，结果等效于 ($x ** $y) mod $mod。

say 7.expmod(-2, 5);     # OUTPUT: «4␤»

方法 polymod§

method polymod(Int:D: +@mods)

返回与 @mods 中除数相对应的模数结果序列，顺序与它们出现在那里的顺序相同。为了获得最佳效果，应从最小的“单位”到最大的“单位”给出除数（例如，每分钟 60 秒，每小时 60 分钟），并且结果以相同的方式返回：从最小到最大（5 秒，4 分钟）。最后一个非零值将是最后一个余数。

say 120.polymod(10);    # OUTPUT: «(0 12)␤» 
say 120.polymod(10,10); # OUTPUT: «(0 2 1)␤»

在第一个案例中，120 除以 10 得到余数 12，它是最后一个元素。在第二个案例中，120 除以 10 得到 12，其余数再次除以 10 得到 2；12 除以 10 的整数除法的结果是最后一个余数。余数的数量将始终比给定的除数数量多一项。如果除数作为惰性列表给出，则运行直到余数为 0 或除数列表用尽。

my $seconds = 1 * 60*60*24 # days 
            + 3 * 60*60    # hours 
            + 4 * 60       # minutes 
            + 5;           # seconds 
 
say $seconds.polymod(60, 60);                # OUTPUT: «(5 4 27)␤» 
say $seconds.polymod(60, 60, 24);            # OUTPUT: «(5 4 3 1)␤» 
 
say 120.polymod:      1, 10, 10², 10³, 10⁴;  # OUTPUT: «(0 0 12 0 0 0)␤» 
say 120.polymod: lazy 1, 10, 10², 10³, 10⁴;  # OUTPUT: «(0 0 12)␤» 
say 120.polymod:      1, 10, 10² … ∞;        # OUTPUT: «(0 0 12)␤» 
my @digits-in-base37 = 9123607.polymod(37 xx *); # Base conversion 
say @digits-in-base37.reverse                    # OUTPUT: «[4 32 4 15 36]␤»

当在 `Int` 上调用时，所有除数都必须是 `Int`。

say 120.polymod(⅓);                            # ERROR

为了说明 `Int` 如何工作，非惰性版本的 polymod，考虑实现它的代码

my $seconds = 2 * 60*60*24 # days 
            + 3 * 60*60    # hours 
            + 4 * 60       # minutes 
            + 5;           # seconds 
 
my @pieces;
for 60, 60, 24 -> $divisor {
    @pieces.push: $seconds mod $divisor;
    $seconds div= $divisor
}
@pieces.push: $seconds;
 
say @pieces; # OUTPUT: «[5 4 3 2]␤»

有关更详细的讨论，请参阅 此博客文章。

我们可以在 `polymod` 中使用惰性列表，只要它们是有限的

my $some-numbers = lazy gather { take 3*$_ for 1..3 };
say 600.polymod( $some-numbers ); # OUTPUT: «(0 2 6 3)␤» 

例程 is-prime§

multi        is-prime (Int:D $number --> Bool:D)
multi method is-prime (Int:D: --> Bool:D)

如果已知此 `Int` 是质数，或基于概率 Miller-Rabin 测试可能为质数，则返回 `True`。

如果已知此 `Int` 不是质数，则返回 `False`。

say 2.is-prime;         # OUTPUT: «True␤» 
say is-prime(9);        # OUTPUT: «False␤»

例程 lsb§

multi method lsb(Int:D:)
multi        lsb(Int:D)

“最低有效位”的缩写。如果数字为 0，则返回 Nil。否则，从数字的二进制表示中最右边最低有效位 (最右边) 的 0 基索引开始返回。

say 0b01011.lsb;        # OUTPUT: «0␤» 
say 0b01010.lsb;        # OUTPUT: «1␤» 
say 0b10100.lsb;        # OUTPUT: «2␤» 
say 0b01000.lsb;        # OUTPUT: «3␤» 
say 0b10000.lsb;        # OUTPUT: «4␤»

例程 msb§

multi method msb(Int:D:)
multi        msb(Int:D)

“最高有效位”的缩写。如果数字为 0，则返回 Nil。否则，从数字的二进制表示中最右边最高有效位 (最左边) 的 0 基索引开始返回。

say 0b00001.msb;        # OUTPUT: «0␤» 
say 0b00011.msb;        # OUTPUT: «1␤» 
say 0b00101.msb;        # OUTPUT: «2␤» 
say 0b01010.msb;        # OUTPUT: «3␤» 
say 0b10011.msb;        # OUTPUT: «4␤»

例程 unival§

multi        unival(Int:D  --> Numeric)
multi method unival(Int:D: --> Numeric)

返回由给定整数表示的 Unicode 代码点表示的数字，或者如果它不表示数字，则返回 NaN。

say ord("¾").unival;    # OUTPUT: «0.75␤» 
say 190.unival;         # OUTPUT: «0.75␤» 
say unival(65);         # OUTPUT: «NaN␤»

方法 Range§

返回表示支持的值范围的 Range 对象。

方法 Bridge§

method Bridge(Int:D: --> Num:D)

返回转换为 Num 的整数。

操作符§

中缀 div§

multi infix:<div>(Int:D, Int:D --> Int:D)

进行整数除法，向下舍入。

类型图§

Int 的类型关系
raku-type-graph Int Int Cool Cool Int->Cool Real Real Int->Real Mu Mu Any Any Any->Mu Cool->Any Numeric Numeric Real->Numeric atomicint atomicint atomicint->Int Bool Bool Bool->Int Stringy Stringy Str Str Str->Cool Str->Stringy Allomorph Allomorph Allomorph->Str IntStr IntStr IntStr->Int IntStr->Allomorph Order Order Order->Int Signal Signal Signal->Int int int int->Int Endian Endian Endian->Int PromiseStatus PromiseStatus PromiseStatus->Int

展开上面的图表