math: core/math.nepl に関する機能を提供するライブラリ

目的もくてき:

• このモジュールの公開 API を提供します。
• 実装の変更時に最小限の doctest 実行経路を維持します。

注意ちゅうい:

• 利用時は各関数の「目的」「注意」「計算量」を確認してください。

#entry main
#target core
fn main <()*>i32> ():
    ()
    0

add: i32 の加算（mod 2^32）

目的もくてき:

• 2つの i32 を加算し、Wasm の i32 加算規則で結果を返します。

実装じっそう:

• target=wasm では i32.add を直接実行します。
• target=llvm では LLVM IR の add i32 に分岐します。

注意ちゅうい:

• オーバーフロー時は 2^32 でラップします。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 42 add 40 2;
    assert_eq_i32 0 add -1 1;

sub: i32 の減算（mod 2^32）

目的もくてき:

• 2つの i32 の差を計算します。

実装じっそう:

• wasm は i32.sub、llvm は sub i32 を使います。

注意ちゅうい:

• 符号付き/符号なしを問わず、ビット列として同じ減算を行います。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 5 sub 9 4;
    assert_eq_i32 -5 sub 4 9;

mul: i32 の乗算（mod 2^32）

目的もくてき:

• 2つの i32 の積を計算します。

実装じっそう:

• wasm は i32.mul、llvm は mul i32 を使います。

注意ちゅうい:

• 積が 32-bit 範囲を超える場合は下位 32-bit が残ります。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 42 mul 6 7;
    assert_eq_i32 0 mul 0 12345;

div_s: i32 の符号付き除算

目的もくてき:

• 符号付き整数として割り算を行います。

実装じっそう:

• wasm は i32.div_s、llvm は sdiv i32 を使います。

注意ちゅうい:

• 0 除算は未定義動作ではなくランタイム trap になります。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 -3 div_s -9 3;
    assert_eq_i32 -3 div_s 10 -3;

div_u: i32 の符号なし除算

目的もくてき:

• 符号なし整数として割り算を行います。

実装じっそう:

• wasm は i32.div_u、llvm は udiv i32 を使います。

注意ちゅうい:

• 引数が負に見える値でも、ビット列を符号なしとみなして計算します。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 3 div_u 11 3;
    assert_eq_i32 2147483647 div_u -1 2;

rem_s: i32 の符号付き剰余

目的もくてき:

• 符号付き除算の余りを計算します。

実装じっそう:

• wasm は i32.rem_s、llvm は srem i32 を使います。

注意ちゅうい:

• 符号付き剰余の符号規則は Wasm/LLVM の仕様に従います。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 1 rem_s 10 3;
    assert_eq_i32 -1 rem_s -10 3;

mod_s: i32 の符号付き剰余（rem_s の別名）
rem_u: i32 の符号なし剰余

目的もくてき:

• 符号なし除算の余りを計算します。

実装じっそう:

• wasm は i32.rem_u、llvm は urem i32 を使います。

注意ちゅうい:

• 結果は常に 0 以上で、除数未満になります。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 2 rem_u 11 3;
    assert_eq_i32 5 rem_u -1 10;

and: i32 のビット AND

目的もくてき:

• i32 と i32 の各ビットに対して AND を取り、両方が 1 のビットだけを残します。

実装じっそう:

• wasm は i32.and、llvm は and i32 を使って同じ結果を返します。

注意ちゅうい:

• ビット演算なので符号は区別しません。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 2 and 6 3;
    assert_eq_i32 7 or 6 3;
    assert_eq_i32 5 xor 6 3;
    assert_eq_i32 8 shl 1 3;
    assert_eq_i32 -2 shr_s -8 2;
    assert_eq_i32 1073741822 shr_u -8 2;
    assert_eq_i32 2 rotl 1 1;
    assert_eq_i32 1 rotr 2 1;

or: i32 のビット OR

目的もくてき:

• i32 と i32 の各ビットに対して OR を取り、どちらかが 1 のビットを立てます。

実装じっそう:

• wasm は i32.or、llvm は or i32 を使います。

注意ちゅうい:

• ビット演算なので符号は区別しません。

計算量けいさんりょう:

• O(1)

xor: i32 のビット XOR

目的もくてき:

• i32 と i32 の各ビットに対して XOR を取り、異なるビットだけを 1 にします。

実装じっそう:

• wasm は i32.xor、llvm は xor i32 を使います。

注意ちゅうい:

• ビット演算なので符号は区別しません。

計算量けいさんりょう:

• O(1)

shl: i32 の左シフト

目的もくてき:

• a のビット列を b だけ左にずらします。

実装じっそう:

• wasm は i32.shl、llvm は shl i32 を使います。

注意ちゅうい:

• シフト量は実行系の規則に従って下位ビットが使われます。

計算量けいさんりょう:

• O(1)

shr_s: i32 の算術右シフト

目的もくてき:

• 符号を保ちながら a を右シフトします。

実装じっそう:

• wasm は i32.shr_s、llvm は ashr i32 を使います。

注意ちゅうい:

• 負数のときは符号拡張されます。

計算量けいさんりょう:

• O(1)

shr_u: i32 の論理右シフト

目的もくてき:

• 上位を 0 で埋めながら a を右シフトします。

実装じっそう:

• wasm は i32.shr_u、llvm は lshr i32 を使います。

注意ちゅうい:

• 符号なし値として扱いたいときに使います。

計算量けいさんりょう:

• O(1)

rotl: i32 の左ローテート

目的もくてき:

• i32 のビット列を左方向に循環回転します。

実装じっそう:

• wasm は i32.rotl、llvm は llvm.fshl.i32 intrinsic を使います。

注意ちゅうい:

• ローテートはシフトと異なり、あふれたビットが反対側に戻ります。

計算量けいさんりょう:

• O(1)

rotr: i32 の右ローテート

目的もくてき:

• i32 のビット列を右方向に循環回転します。

実装じっそう:

• wasm は i32.rotr、llvm は llvm.fshr.i32 intrinsic を使います。

注意ちゅうい:

• ローテートはシフトと異なり、あふれたビットが反対側に戻ります。

計算量けいさんりょう:

• O(1)

clz: 先頭ゼロビット数を数える

目的もくてき:

• i32 の上位側に連続する 0 ビット数を返します。

実装じっそう:

• wasm は i32.clz、llvm は llvm.ctlz.i32 intrinsic を使います。

注意ちゅうい:

• 入力が 0 の場合も実行系の規約に沿って定義されます。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert_eq_i32 31 clz 1;
    assert_eq_i32 3 ctz 8;
    assert_eq_i32 4 popcnt 15;

ctz: 末尾ゼロビット数を数える

目的もくてき:

• i32 の下位側に連続する 0 ビット数を返します。

実装じっそう:

• wasm は i32.ctz、llvm は llvm.cttz.i32 intrinsic を使います。

注意ちゅうい:

• 入力が 0 の場合も実行系の規約に沿って定義されます。

計算量けいさんりょう:

• O(1)

popcnt: 1 ビットの個数を数える

目的もくてき:

• i32 のビット列に含まれる 1 の個数を返します。

実装じっそう:

• wasm は i32.popcnt、llvm は llvm.ctpop.i32 intrinsic を使います。

注意ちゅうい:

• 値の符号には依存しません。

計算量けいさんりょう:

• O(1)

eq: i32 の等値比較

目的もくてき:

• 2つの i32 が等しいとき true、異なるとき false を返します。

実装じっそう:

• wasm は i32.eq、llvm は icmp eq を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    assert eq 7 7;
    assert ne 7 8;
    assert lt -1 0;
    assert lt_u 0 -1;
    assert le 7 7;
    assert le_u 7 8;
    assert gt 9 3;
    assert gt_u -1 0;
    assert ge 9 9;
    assert ge_u -1 -1;

ne: i32 の非等値比較

目的もくてき:

• 2つの i32 が異なるとき true を返します。

実装じっそう:

• wasm は i32.ne、llvm は icmp ne を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

lt: i32 の符号付き小なり比較

目的もくてき:

• i32 を符号付き整数として比較し、a < b を判定します。

実装じっそう:

• wasm は i32.lt_s、llvm は icmp slt を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

lt_u: i32 の符号なし小なり比較

目的もくてき:

• i32 を符号なし整数として比較し、a < b を判定します。

実装じっそう:

• wasm は i32.lt_u、llvm は icmp ult を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

le: i32 の符号付き以下比較

目的もくてき:

• i32 を符号付き整数として比較し、a <= b を判定します。

実装じっそう:

• wasm は i32.le_s、llvm は icmp sle を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

le_u: i32 の符号なし以下比較

目的もくてき:

• i32 を符号なし整数として比較し、a <= b を判定します。

実装じっそう:

• wasm は i32.le_u、llvm は icmp ule を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

gt: i32 の符号付き大なり比較

目的もくてき:

• i32 を符号付き整数として比較し、a > b を判定します。

実装じっそう:

• wasm は i32.gt_s、llvm は icmp sgt を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

gt_u: i32 の符号なし大なり比較

目的もくてき:

• i32 を符号なし整数として比較し、a > b を判定します。

実装じっそう:

• wasm は i32.gt_u、llvm は icmp ugt を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

ge: i32 の符号付き以上比較

目的もくてき:

• i32 を符号付き整数として比較し、a >= b を判定します。

実装じっそう:

• wasm は i32.ge_s、llvm は icmp sge を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

ge_u: i32 の符号なし以上比較

目的もくてき:

• i32 を符号なし整数として比較し、a >= b を判定します。

実装じっそう:

• wasm は i32.ge_u、llvm は icmp uge を使います。

注意ちゅうい:

• 返り値は bool 型です。

計算量けいさんりょう:

• O(1)

add_u8: u8 の加算（mod 2^8）

目的もくてき:

• u8 と u8 を加算します。

実装じっそう:

• i32 演算で加算した後、0xff でマスクして下位 8-bit を残します。

注意ちゅうい:

• オーバーフロー時は 8-bit でラップします。

計算量けいさんりょう:

• O(1)

sub_u8: u8 の減算（mod 2^8）

目的もくてき:

• u8 から u8 を減算します。

実装じっそう:

• i32 演算で減算した後、0xff でマスクして下位 8-bit を残します。

注意ちゅうい:

• 負の結果は 8-bit でラップします。

計算量けいさんりょう:

• O(1)

mul_u8: u8 の乗算（mod 2^8）

目的もくてき:

• u8 と u8 の積を計算します。

実装じっそう:

• i32 演算で乗算した後、0xff でマスクして下位 8-bit を残します。

注意ちゅうい:

• 大きな積は 8-bit でラップします。

計算量けいさんりょう:

• O(1)

div_u_u8: u8 の符号なし除算

目的もくてき:

• u8 を符号なし整数として除算します。

実装じっそう:

• wasm は i32.div_u、llvm は udiv i32 を使います。

注意ちゅうい:

• 0 除算は trap になります。

計算量けいさんりょう:

• O(1)

rem_u_u8: u8 の符号なし剰余

目的もくてき:

• u8 を符号なし整数として剰余を計算します。

実装じっそう:

• wasm は i32.rem_u、llvm は urem i32 を使います。

注意ちゅうい:

• 0 除算は trap になります。

計算量けいさんりょう:

• O(1)

eq_u8: u8 の等値比較

目的もくてき:

• u8 の a == b を判定します。

実装じっそう:

• wasm は i32.eq、llvm は icmp eq を使います。

注意ちゅうい:

• 結果は bool（0/1）です。

計算量けいさんりょう:

• O(1)

ne_u8: u8 の非等値比較

目的もくてき:

• u8 の a != b を判定します。

実装じっそう:

• wasm は i32.ne、llvm は icmp ne を使います。

注意ちゅうい:

• 結果は bool（0/1）です。

計算量けいさんりょう:

• O(1)

lt_u_u8: u8 の符号なし小なり比較

目的もくてき:

• u8 を符号なし整数として a < b を判定します。

実装じっそう:

• wasm は i32.lt_u、llvm は icmp ult を使います。

注意ちゅうい:

• 結果は bool（0/1）です。

計算量けいさんりょう:

• O(1)

le_u_u8: u8 の符号なし以下比較

目的もくてき:

• u8 を符号なし整数として a <= b を判定します。

実装じっそう:

• wasm は i32.le_u、llvm は icmp ule を使います。

注意ちゅうい:

• 結果は bool（0/1）です。

計算量けいさんりょう:

• O(1)

gt_u_u8: u8 の符号なし大なり比較

目的もくてき:

• u8 を符号なし整数として a > b を判定します。

実装じっそう:

• wasm は i32.gt_u、llvm は icmp ugt を使います。

注意ちゅうい:

• 結果は bool（0/1）です。

計算量けいさんりょう:

• O(1)

ge_u_u8: u8 の符号なし以上比較

目的もくてき:

• u8 を符号なし整数として a >= b を判定します。

実装じっそう:

• wasm は i32.ge_u、llvm は icmp uge を使います。

注意ちゅうい:

• 結果は bool（0/1）です。

計算量けいさんりょう:

• O(1)

add: u8 の加算（mod 2^8）
sub: u8 の減算（mod 2^8）
mul: u8 の乗算（mod 2^8）
div_u: u8 の符号なし除算
rem_u: u8 の符号なし剰余
eq: u8 の等値比較
ne: u8 の非等値比較
lt_u: u8 の符号なし小なり比較
le_u: u8 の符号なし以下比較
gt_u: u8 の符号なし大なり比較
ge_u: u8 の符号なし以上比較
add: i64 の加算（mod 2^64）

目的もくてき:

• i64 と i64 を加算します。

実装じっそう:

• wasm は i64.add、llvm は add i64 を使います。

注意ちゅうい:

• オーバーフロー時は下位 64-bit が残ります。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast 40;
    let b <i64> cast 2;
    let r0 <i64> add a b;
    assert eq r0 <i64> cast 42;
    let a <i64> cast 0;
    let b <i64> cast 7;
    let r1 <i64> add a b;
    assert eq r1 b;

sub: i64 の減算（mod 2^64）

目的もくてき:

• i64 から i64 を減算します。

実装じっそう:

• wasm は i64.sub、llvm は sub i64 を使います。

注意ちゅうい:

• 結果は 64-bit 符号付き値として解釈されますが、演算自体は 64-bit ラップです。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast 44;
    let b <i64> cast 2;
    let r0 <i64> sub a b;
    assert eq r0 <i64> cast 42;
    let z <i64> cast 0;
    let one <i64> cast 1;
    let r1 <i64> sub z one;
    assert lt r1 z;

mul: i64 の乗算（mod 2^64）

目的もくてき:

• i64 と i64 を乗算します。

実装じっそう:

• wasm は i64.mul、llvm は mul i64 を使います。

注意ちゅうい:

• 乗算結果が 64-bit を超える場合はラップします。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast 6;
    let b <i64> cast 7;
    let r0 <i64> mul a b;
    assert eq r0 <i64> cast 42;
    let z <i64> cast 0;
    let n <i64> cast 999;
    let r1 <i64> mul z n;
    assert eq r1 z;

div_s: i64 の符号付き除算

目的もくてき:

• i64 を符号付き整数として割り算します。

実装じっそう:

• wasm 命令 i64.div_s を直接実行します。

注意ちゅうい:

• 0 除算は trap します。
• 最小値 -2^63 を -1 で割るケースも trap します。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let n9 <i64> cast -9;
    let p9 <i64> cast 9;
    let p3 <i64> cast 3;
    let n3 <i64> cast -3;
    let p <i64> div_s n9 p3;
    let q <i64> div_s p9 n3;
    assert eq p <i64> cast -3;
    assert eq q <i64> cast -3;

div_u: i64 の符号なし除算

目的もくてき:

• i64 を符号なし整数として割り算します。

実装じっそう:

• wasm は i64.div_u、llvm は udiv i64 を使います。

注意ちゅうい:

• 0 除算は trap します。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast 100;
    let b <i64> cast 9;
    let r0 <i64> div_u a b;
    assert eq r0 <i64> cast 11;
    let a <i64> cast 9;
    let b <i64> cast 10;
    let r1 <i64> div_u a b;
    assert eq r1 <i64> cast 0;

rem_s: i64 の符号付き剰余

目的もくてき:

• i64 の符号付き剰余（余り）を計算します。

実装じっそう:

• wasm 命令 i64.rem_s を直接実行します。

注意ちゅうい:

• 余りの符号は被除数（左辺）に従います。
• 0 除算は trap します。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let n10 <i64> cast -10;
    let p10 <i64> cast 10;
    let p3 <i64> cast 3;
    let a <i64> rem_s n10 p3;
    let b <i64> rem_s p10 p3;
    assert eq a <i64> cast -1;
    assert eq b <i64> cast 1;

rem_u: i64 の符号なし剰余

目的もくてき:

• i64 の符号なし剰余を計算します。

実装じっそう:

• wasm は i64.rem_u、llvm は urem i64 を使います。

注意ちゅうい:

• 戻り値は 0 以上かつ除数未満です。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast 100;
    let b <i64> cast 9;
    let r0 <i64> rem_u a b;
    assert eq r0 <i64> cast 1;
    let a <i64> cast 9;
    let b <i64> cast 10;
    let r1 <i64> rem_u a b;
    assert eq r1 a;

and: i64 のビット AND

目的もくてき:

• 2つの i64 の各ビットに AND を適用します。

実装じっそう:

• wasm 命令 i64.and を直接実行します。

注意ちゅうい:

• 演算は整数の符号とは無関係にビット単位で行われます。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast 14;
    let b <i64> cast 11;
    let r_and <i64> and a b;
    let r_or <i64> or a b;
    let r_xor <i64> xor a b;
    assert eq r_and <i64> cast 10;
    assert eq r_or <i64> cast 15;
    assert eq r_xor <i64> cast 5;

or: i64 のビット OR

目的もくてき:

• 2つの i64 の各ビットに OR を適用します。

実装じっそう:

• wasm 命令 i64.or を直接実行します。

注意ちゅうい:

• 真理値 OR ではなく、ビット論理和です。

計算量けいさんりょう:

• O(1)

xor: i64 のビット XOR

目的もくてき:

• 2つの i64 の各ビットに XOR を適用します。

実装じっそう:

• wasm 命令 i64.xor を直接実行します。

注意ちゅうい:

• 異なるビットのみ 1 になる排他的論理和です。

計算量けいさんりょう:

• O(1)

shl: i64 の左シフト

目的もくてき:

• i64 のビット列を左へシフトします。

実装じっそう:

• wasm 命令 i64.shl を直接実行します。

注意ちゅうい:

• シフト量は Wasm 仕様に従い下位 6 bit が使われます。

計算量けいさんりょう:

• O(1)

shr_s: i64 の算術右シフト

目的もくてき:

• i64 を符号付き整数として右へシフトします。

実装じっそう:

• wasm 命令 i64.shr_s を直接実行します。

注意ちゅうい:

• 最上位ビット（符号ビット）が埋め戻されます。

計算量けいさんりょう:

• O(1)

shr_u: i64 の論理右シフト

目的もくてき:

• i64 を符号なし整数として右へシフトします。

実装じっそう:

• wasm 命令 i64.shr_u を直接実行します。

注意ちゅうい:

• 上位ビットは 0 で埋められます。

計算量けいさんりょう:

• O(1)

rotl: i64 の左ローテート

目的もくてき:

• i64 のビット列を左へ循環シフトします。

実装じっそう:

• wasm 命令 i64.rotl を直接実行します。

注意ちゅうい:

• シフトで失われるビットは下位側へ回り込みます。

計算量けいさんりょう:

• O(1)

rotr: i64 の右ローテート

目的もくてき:

• i64 のビット列を右へ循環シフトします。

実装じっそう:

• wasm 命令 i64.rotr を直接実行します。

注意ちゅうい:

• シフトで失われるビットは上位側へ回り込みます。

計算量けいさんりょう:

• O(1)

clz: 先頭ゼロビット数の計算

目的もくてき:

• i64 の先頭側に連続する 0 bit の個数を返します。

実装じっそう:

• wasm 命令 i64.clz を直接実行します。

注意ちゅうい:

• 入力が 0 のときは 64 を返します。

計算量けいさんりょう:

• O(1)

ctz: 末尾ゼロビット数の計算

目的もくてき:

• i64 の末尾側に連続する 0 bit の個数を返します。

実装じっそう:

• wasm 命令 i64.ctz を直接実行します。

注意ちゅうい:

• 入力が 0 のときは 64 を返します。

計算量けいさんりょう:

• O(1)

popcnt: 1 ビット数の計算

目的もくてき:

• i64 に立っている 1 bit の個数を返します。

実装じっそう:

• wasm 命令 i64.popcnt を直接実行します。

注意ちゅうい:

• ハミング重み（population count）として利用できます。

計算量けいさんりょう:

• O(1)

eq: i64 の等値比較

目的もくてき:

• 2つの i64 が等しいかを判定します。

実装じっそう:

• wasm 命令 i64.eq を直接実行します。

注意ちゅうい:

• 比較はビット列が一致するかで判定されます。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let a <i64> cast -1;
    let b <i64> cast 1;
    let c <i64> cast -2;
    let d <i64> cast -1;
    assert eq a d;
    assert ne a b;
    assert lt c d;
    assert gt_u a b;

ne: i64 の非等値比較

目的もくてき:

• 2つの i64 が異なるかを判定します。

実装じっそう:

• wasm 命令 i64.ne を直接実行します。

注意ちゅうい:

• eq の否定と同値です。

計算量けいさんりょう:

• O(1)

lt: i64 の符号付き小なり比較

目的もくてき:

• i64 を符号付き整数として a < b を判定します。

実装じっそう:

• wasm 命令 i64.lt_s を直接実行します。

注意ちゅうい:

• 負数を含む順序関係を使うときはこちらを使います。

計算量けいさんりょう:

• O(1)

lt_u: i64 の符号なし小なり比較

目的もくてき:

• i64 を符号なし整数として a < b を判定します。

実装じっそう:

• wasm 命令 i64.lt_u を直接実行します。

注意ちゅうい:

• 上位ビットが立っている値は大きな正数として扱われます。

計算量けいさんりょう:

• O(1)

le: i64 の符号付き以下比較

目的もくてき:

• i64 を符号付き整数として a <= b を判定します。

実装じっそう:

• wasm 命令 i64.le_s を直接実行します。

注意ちゅうい:

• lt と eq の和集合と同じ真理値になります。

計算量けいさんりょう:

• O(1)

le_u: i64 の符号なし以下比較

目的もくてき:

• i64 を符号なし整数として a <= b を判定します。

実装じっそう:

• wasm 命令 i64.le_u を直接実行します。

注意ちゅうい:

• 符号付き比較とは結果が異なる場合があります。

計算量けいさんりょう:

• O(1)

gt: i64 の符号付き大なり比較

目的もくてき:

• i64 を符号付き整数として a > b を判定します。

実装じっそう:

• wasm 命令 i64.gt_s を直接実行します。

注意ちゅうい:

• 負数を含む大小比較に使用します。

計算量けいさんりょう:

• O(1)

gt_u: i64 の符号なし大なり比較

目的もくてき:

• i64 を符号なし整数として a > b を判定します。

実装じっそう:

• wasm 命令 i64.gt_u を直接実行します。

注意ちゅうい:

• 上位ビットが立つ値は大きい値として判定されます。

計算量けいさんりょう:

• O(1)

ge: i64 の符号付き以上比較

目的もくてき:

• i64 を符号付き整数として a >= b を判定します。

実装じっそう:

• wasm 命令 i64.ge_s を直接実行します。

注意ちゅうい:

• gt または eq が真なら真になります。

計算量けいさんりょう:

• O(1)

ge_u: i64 の符号なし以上比較

目的もくてき:

• i64 を符号なし整数として a >= b を判定します。

実装じっそう:

• wasm 命令 i64.ge_u を直接実行します。

注意ちゅうい:

• gt_u または eq が真なら真になります。

計算量けいさんりょう:

• O(1)

add: f32 の加算

目的もくてき:

• 2つの f32 を加算します。

実装じっそう:

• wasm は f32.add、llvm は fadd float を実行します。

注意ちゅうい:

• 丸め・NaN・±∞の扱いは IEEE 754 と各 backend の仕様に従います。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let x <f32> add 1.5 2.25;
    let y <f32> sub x 1.25;
    assert eq x 3.75;
    assert eq y 2.5;

sub: f32 の減算

目的もくてき:

• 2つの f32 の差を計算します。

実装じっそう:

• wasm は f32.sub、llvm は fsub float を実行します。

注意ちゅうい:

• NaN が関与する場合は比較で偽になる点に注意してください。

計算量けいさんりょう:

• O(1)

mul: f32 の乗算

目的もくてき:

• 2つの f32 の積を計算します。

実装じっそう:

• wasm は f32.mul、llvm は fmul float を実行します。

注意ちゅうい:

• 大きな値同士では +∞ や -∞ へ飽和することがあります。

計算量けいさんりょう:

• O(1)

div: f32 の除算

目的もくてき:

• 2つの f32 の商を計算します。

実装じっそう:

• wasm は f32.div、llvm は fdiv float を実行します。

注意ちゅうい:

• 整数除算と異なり、0 除算は trap せず ±∞ / NaN になります。

計算量けいさんりょう:

• O(1)

sqrt_f32: f32 の平方根

目的もくてき:

• f32 の平方根を返します。

実装じっそう:

• wasm は f32.sqrt を実行します。
• llvm は llvm.sqrt.f32 intrinsic を呼びます。

注意ちゅうい:

• 負数入力は NaN になります。

計算量けいさんりょう:

• O(1)

abs_f32: f32 の絶対値

目的もくてき:

• f32 の符号を取り除いた絶対値を返します。

実装じっそう:

• wasm は f32.abs を使います。
• llvm は bitcast -> and mask -> bitcast で符号ビットのみを落とします。

注意ちゅうい:

• NaN の payload は backend の仕様に従います。

計算量けいさんりょう:

• O(1)

neg: f32 の符号反転

目的もくてき:

• f32 の符号を反転した値 -a を返します。

実装じっそう:

• wasm は f32.neg、llvm は fneg float を使います。

注意ちゅうい:

• -0.0 と +0.0 は符号が反転します。

計算量けいさんりょう:

• O(1)

ceil_f32: f32 の切り上げ

目的もくてき:

• f32 を「以上の最小整数値」へ切り上げます。

実装じっそう:

• wasm は f32.ceil、llvm は llvm.ceil.f32 を使います。

注意ちゅうい:

• 戻り値の型は f32 のままです。

計算量けいさんりょう:

• O(1)

floor_f32: f32 の切り下げ

目的もくてき:

• f32 を「以下の最大整数値」へ切り下げます。

実装じっそう:

• wasm は f32.floor、llvm は llvm.floor.f32 を使います。

注意ちゅうい:

• 戻り値の型は f32 のままです。

計算量けいさんりょう:

• O(1)

trunc_f32: f32 の小数部切り捨て

目的もくてき:

• f32 の小数部を 0 方向へ切り捨てます。

実装じっそう:

• wasm は f32.trunc、llvm は llvm.trunc.f32 を使います。

注意ちゅうい:

• 負数では切り下げではなく 0 方向へ寄ります。

計算量けいさんりょう:

• O(1)

nearest_f32: f32 の最近接整数丸め

目的もくてき:

• f32 を最近接整数へ丸めます。

実装じっそう:

• wasm は f32.nearest、llvm は llvm.nearbyint.f32 を使います。

注意ちゅうい:

• 中間値（x.5）は backend の丸め規則に従います。

計算量けいさんりょう:

• O(1)

min_f32: f32 の最小値

目的もくてき:

• 2つの f32 から小さい方を返します。

実装じっそう:

• wasm は f32.min、llvm は llvm.minimum.f32 を使います。

注意ちゅうい:

• NaN 入力時の振る舞いは backend 仕様に従います。

計算量けいさんりょう:

• O(1)

max_f32: f32 の最大値

目的もくてき:

• 2つの f32 から大きい方を返します。

実装じっそう:

• wasm は f32.max、llvm は llvm.maximum.f32 を使います。

注意ちゅうい:

• NaN 入力時の振る舞いは backend 仕様に従います。

計算量けいさんりょう:

• O(1)

copysign_f32: f32 の符号コピー

目的もくてき:

• 第1引数の絶対値に、第2引数の符号ビットを適用した値を返します。

実装じっそう:

• wasm は f32.copysign、llvm は llvm.copysign.f32 を使います。

注意ちゅうい:

• 値の大きさは第1引数、符号のみ第2引数から採用されます。

計算量けいさんりょう:

• O(1)

eq: f32 の等値比較

目的もくてき:

• 2つの f32 が等しいかを判定します。

実装じっそう:

• wasm は f32.eq、llvm は fcmp oeq を使います。

注意ちゅうい:

• NaN を含む比較は false になります。

計算量けいさんりょう:

• O(1)

ne: f32 の非等値比較

目的もくてき:

• 2つの f32 が異なるかを判定します。

実装じっそう:

• wasm は f32.ne、llvm は fcmp une を使います。

注意ちゅうい:

• NaN を含む比較は true になります。

計算量けいさんりょう:

• O(1)

lt: f32 の小なり比較

目的もくてき:

• a < b を判定します。

実装じっそう:

• wasm は f32.lt、llvm は fcmp olt を使います。

注意ちゅうい:

• NaN を含むと false です。

計算量けいさんりょう:

• O(1)

le: f32 の以下比較

目的もくてき:

• a <= b を判定します。

実装じっそう:

• wasm は f32.le、llvm は fcmp ole を使います。

注意ちゅうい:

• NaN を含むと false です。

計算量けいさんりょう:

• O(1)

gt: f32 の大なり比較

目的もくてき:

• a > b を判定します。

実装じっそう:

• wasm は f32.gt、llvm は fcmp ogt を使います。

注意ちゅうい:

• NaN を含むと false です。

計算量けいさんりょう:

• O(1)

ge: f32 の以上比較

目的もくてき:

• a >= b を判定します。

実装じっそう:

• wasm は f32.ge、llvm は fcmp oge を使います。

注意ちゅうい:

• NaN を含むと false です。

計算量けいさんりょう:

• O(1)

add: f64 の加算

目的もくてき:

• 2つの f64 を加算します。

実装じっそう:

• wasm は f64.add、llvm は fadd double を実行します。

注意ちゅうい:

• 丸め誤差や NaN の伝播は IEEE 754 の規則に従います。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let one <f64> cast 1;
    let two <f64> cast 2;
    let three <f64> cast 3;
    let six <f64> cast 6;
    let x <f64> add one two;
    let y <f64> mul x two;
    assert eq x three;
    assert eq y six;

sub: f64 の減算

目的もくてき:

• 2つの f64 の差を計算します。

実装じっそう:

• wasm は f64.sub、llvm は fsub double を実行します。

注意ちゅうい:

• 丸めの影響で (a - b) + b が常に a になるとは限りません。

計算量けいさんりょう:

• O(1)

mul: f64 の乗算

目的もくてき:

• 2つの f64 の積を計算します。

実装じっそう:

• wasm は f64.mul、llvm は fmul double を実行します。

注意ちゅうい:

• 大きい値では ±∞、非数値入力では NaN になります。

計算量けいさんりょう:

• O(1)

div: f64 の除算

目的もくてき:

• 2つの f64 の商を計算します。

実装じっそう:

• wasm は f64.div、llvm は fdiv double を実行します。

注意ちゅうい:

• 整数演算とは異なり 0 除算で trap せず、±∞ や NaN が返ります。

計算量けいさんりょう:

• O(1)

sqrt_f64: f64 の平方根

目的もくてき:

• f64 の平方根を返します。

実装じっそう:

• wasm は f64.sqrt を実行します。
• llvm は llvm.sqrt.f64 intrinsic を呼びます。

注意ちゅうい:

• 負数入力は NaN になります。

計算量けいさんりょう:

• O(1)

abs_f64: f64 の絶対値

目的もくてき:

• f64 の符号を取り除いた絶対値を返します。

実装じっそう:

• wasm は f64.abs を使います。
• llvm は bitcast -> and mask -> bitcast で符号ビットのみを落とします。

注意ちゅうい:

• NaN の payload は backend の仕様に従います。

計算量けいさんりょう:

• O(1)

neg: f64 の符号反転

目的もくてき:

• f64 の符号を反転した値 -a を返します。

実装じっそう:

• wasm は f64.neg、llvm は fneg double を使います。

注意ちゅうい:

• -0.0 と +0.0 は区別されるため、符号反転で相互変換されます。

計算量けいさんりょう:

• O(1)

ceil_f64: f64 の切り上げ

目的もくてき:

• f64 を「以上の最小整数値」へ切り上げます。

実装じっそう:

• wasm は f64.ceil、llvm は llvm.ceil.f64 を使います。

注意ちゅうい:

• 戻り値の型は f64 のままです。

計算量けいさんりょう:

• O(1)

floor_f64: f64 の切り下げ

目的もくてき:

• f64 を「以下の最大整数値」へ切り下げます。

実装じっそう:

• wasm は f64.floor、llvm は llvm.floor.f64 を使います。

注意ちゅうい:

• 戻り値の型は f64 のままです。

計算量けいさんりょう:

• O(1)

trunc_f64: f64 の小数部切り捨て

目的もくてき:

• f64 の小数部を 0 方向へ切り捨てます。

実装じっそう:

• wasm は f64.trunc、llvm は llvm.trunc.f64 を使います。

注意ちゅうい:

• 負数では切り下げではなく 0 方向へ寄ります。

計算量けいさんりょう:

• O(1)

nearest_f64: f64 の最近接整数丸め

目的もくてき:

• f64 を最近接整数へ丸めます。

実装じっそう:

• wasm は f64.nearest、llvm は llvm.nearbyint.f64 を使います。

注意ちゅうい:

• 中間値（x.5）は backend の丸め規則に従います。

計算量けいさんりょう:

• O(1)

min_f64: f64 の最小値

目的もくてき:

• 2つの f64 から小さい方を返します。

実装じっそう:

• wasm は f64.min、llvm は llvm.minimum.f64 を使います。

注意ちゅうい:

• NaN 入力時の振る舞いは backend 仕様に従います。

計算量けいさんりょう:

• O(1)

max_f64: f64 の最大値

目的もくてき:

• 2つの f64 から大きい方を返します。

実装じっそう:

• wasm は f64.max、llvm は llvm.maximum.f64 を使います。

注意ちゅうい:

• NaN 入力時の振る舞いは backend 仕様に従います。

計算量けいさんりょう:

• O(1)

copysign_f64: f64 の符号コピー

目的もくてき:

• 第1引数の絶対値に、第2引数の符号ビットを適用した値を返します。

実装じっそう:

• wasm は f64.copysign、llvm は llvm.copysign.f64 を使います。

注意ちゅうい:

• 値の大きさは第1引数、符号のみ第2引数から採用されます。

計算量けいさんりょう:

• O(1)

eq: f64 の等値比較

目的もくてき:

• 2つの f64 が等しいかを判定します。

実装じっそう:

• wasm は f64.eq、llvm は fcmp oeq を使います。

注意ちゅうい:

• NaN を含む比較は false です。

計算量けいさんりょう:

• O(1)

ne: f64 の非等値比較

目的もくてき:

• 2つの f64 が異なるかを判定します。

実装じっそう:

• wasm は f64.ne、llvm は fcmp une を使います。

注意ちゅうい:

• NaN を含む比較は true です。

計算量けいさんりょう:

• O(1)

lt: f64 の小なり比較

目的もくてき:

• a < b を判定します。

実装じっそう:

• wasm は f64.lt、llvm は fcmp olt を使います。

注意ちゅうい:

• NaN を含む比較は false です。

計算量けいさんりょう:

• O(1)

le: f64 の以下比較

目的もくてき:

• a <= b を判定します。

実装じっそう:

• wasm は f64.le、llvm は fcmp ole を使います。

注意ちゅうい:

• NaN を含む比較は false です。

計算量けいさんりょう:

• O(1)

gt: f64 の大なり比較

目的もくてき:

• a > b を判定します。

実装じっそう:

• wasm は f64.gt、llvm は fcmp ogt を使います。

注意ちゅうい:

• NaN を含む比較は false です。

計算量けいさんりょう:

• O(1)

ge: f64 の以上比較

目的もくてき:

• a >= b を判定します。

実装じっそう:

• wasm は f64.ge、llvm は fcmp oge を使います。

注意ちゅうい:

• NaN を含む比較は false です。

計算量けいさんりょう:

• O(1)

extend8_s_i32: i8 相当値の符号拡張

目的もくてき:

• i32 下位 8 bit を符号付き値として i32 へ拡張します。

実装じっそう:

• wasm は i32.extend8_s を使います。
• llvm は shl 24 後に ashr 24 で符号拡張します。

注意ちゅうい:

• 上位 24 bit は入力の符号に応じて埋められます。

計算量けいさんりょう:

• O(1)

extend16_s_i32: i16 相当値の符号拡張

目的もくてき:

• i32 下位 16 bit を符号付き値として i32 へ拡張します。

実装じっそう:

• wasm は i32.extend16_s を使います。
• llvm は shl 16 後に ashr 16 で符号拡張します。

注意ちゅうい:

• 上位 16 bit は入力の符号に応じて埋められます。

計算量けいさんりょう:

• O(1)

<i64> cast: i32 を符号拡張して i64 へ変換する

目的もくてき:

• i32 の符号を保ったまま i64 に拡張します。

実装じっそう:

• wasm は i64.extend_i32_s、llvm は sext i32 to i64 を使います。

注意ちゅうい:

• 負値は上位ビットが 1 で埋められます。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let v <i64> cast -1;
    assert lt v <i64> cast 0;
    let v <i64> cast 123;
    assert eq v <i64> cast 123;

<i64> cast: i32 をゼロ拡張して i64 へ変換する

目的もくてき:

• i32 を符号なし値として i64 に拡張します。

実装じっそう:

• wasm は i64.extend_i32_u、llvm は zext i32 to i64 を使います。

注意ちゅうい:

• 32-bit 上位は必ず 0 になります。

計算量けいさんりょう:

• O(1)

#entry main
#target core
#import "core/test" as *
#import "core/cast" as *
#import "core/math" as *
fn main <()*>()> ():
    let v <i64> cast -1;
    assert gt_u v <i64> cast 0;
    let v <i64> cast 1;
    assert eq v <i64> cast 1;

wrap_i64_to_i32: i64 を i32 へ切り詰める

目的もくてき:

• i64 の下位 32 bit を取り出して i32 として返します。

実装じっそう:

• wasm は i32.wrap_i64、llvm は trunc i64 to i32 を使います。

注意ちゅうい:

• 上位 32 bit は破棄されます。

計算量けいさんりょう:

• O(1)

convert_s_i32_to_f32: i32(符号付き) を f32 へ変換

目的もくてき:

• 符号付き i32 を f32 に変換します。

実装じっそう:

• wasm は f32.convert_i32_s、llvm は sitofp i32 to float を使います。

注意ちゅうい:

• 大きい整数は f32 で正確に表現できない場合があります。

計算量けいさんりょう:

• O(1)

convert_u_i32_to_f32: i32(符号なし) を f32 へ変換

目的もくてき:

• 符号なし i32 を f32 に変換します。

実装じっそう:

• wasm は f32.convert_i32_u、llvm は uitofp i32 to float を使います。

注意ちゅうい:

• 符号付き値としては負に見えるビット列も、大きな正数として解釈されます。

計算量けいさんりょう:

• O(1)

convert_s_i64_to_f32: i64(符号付き) を f32 へ変換

目的もくてき:

• 符号付き i64 を f32 に変換します。

実装じっそう:

• wasm は f32.convert_i64_s、llvm は sitofp i64 to float を使います。

注意ちゅうい:

• 表現可能桁数を超える場合は丸めが発生します。

計算量けいさんりょう:

• O(1)

convert_u_i64_to_f32: i64(符号なし) を f32 へ変換

目的もくてき:

• 符号なし i64 を f32 に変換します。

実装じっそう:

• wasm は f32.convert_i64_u、llvm は uitofp i64 to float を使います。

注意ちゅうい:

• 非常に大きな値では丸め誤差が大きくなることがあります。

計算量けいさんりょう:

• O(1)

trunc_s_f32_to_i32: f32 を i32(符号付き)へ切り捨て変換

目的もくてき:

• f32 を 0 方向へ切り捨てて符号付き i32 に変換します。

実装じっそう:

• wasm は i32.trunc_f32_s、llvm は fptosi float to i32 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_u_f32_to_i32: f32 を i32(符号なし)へ切り捨て変換

目的もくてき:

• f32 を 0 方向へ切り捨てて符号なし i32 に変換します。

実装じっそう:

• wasm は i32.trunc_f32_u、llvm は fptoui float to i32 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_sat_s_f32_to_i32: f32 を i32(符号付き)へ飽和変換

目的もくてき:

• f32 を i32 に変換し、範囲外は最小値/最大値に丸めます。

実装じっそう:

• wasm は i32.trunc_sat_f32_s を使います。
• llvm は llvm.fptosi.sat.i32.f32 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

trunc_sat_u_f32_to_i32: f32 を i32(符号なし)へ飽和変換

目的もくてき:

• f32 を i32 に変換し、範囲外は 0 か最大値に丸めます。

実装じっそう:

• wasm は i32.trunc_sat_f32_u を使います。
• llvm は llvm.fptoui.sat.i32.f32 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

trunc_s_f32_to_i64: f32 を i64(符号付き)へ切り捨て変換

目的もくてき:

• f32 を 0 方向へ切り捨てて i64 に変換します。

実装じっそう:

• wasm は i64.trunc_f32_s、llvm は fptosi float to i64 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_u_f32_to_i64: f32 を i64(符号なし)へ切り捨て変換

目的もくてき:

• f32 を 0 方向へ切り捨てて i64 に変換します。

実装じっそう:

• wasm は i64.trunc_f32_u、llvm は fptoui float to i64 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_sat_s_f32_to_i64: f32 を i64(符号付き)へ飽和変換

目的もくてき:

• f32 を i64 に変換し、範囲外は最小値/最大値へ丸めます。

実装じっそう:

• wasm は i64.trunc_sat_f32_s を使います。
• llvm は llvm.fptosi.sat.i64.f32 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

trunc_sat_u_f32_to_i64: f32 を i64(符号なし)へ飽和変換

目的もくてき:

• f32 を i64 に変換し、範囲外は 0 か最大値へ丸めます。

実装じっそう:

• wasm は i64.trunc_sat_f32_u を使います。
• llvm は llvm.fptoui.sat.i64.f32 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

<f64> cast: i32(符号付き) を f64 へ変換

目的もくてき:

• 符号付き i32 を f64 に変換します。

実装じっそう:

• wasm は f64.convert_i32_s、llvm は sitofp i32 to double を使います。

注意ちゅうい:

• 大きな整数でも f32 より高い精度で保持できます。

計算量けいさんりょう:

• O(1)

convert_u_i32_to_f64: i32(符号なし) を f64 へ変換

目的もくてき:

• 符号なし i32 を f64 に変換します。

実装じっそう:

• wasm は f64.convert_i32_u、llvm は uitofp i32 to double を使います。

注意ちゅうい:

• 符号付き値として負に見えるビット列も大きな正数として扱われます。

計算量けいさんりょう:

• O(1)

convert_s_i64_to_f64: i64(符号付き) を f64 へ変換

目的もくてき:

• 符号付き i64 を f64 に変換します。

実装じっそう:

• wasm は f64.convert_i64_s、llvm は sitofp i64 to double を使います。

注意ちゅうい:

• 2^53 を超える整数は厳密には表現できず丸めが入ります。

計算量けいさんりょう:

• O(1)

convert_u_i64_to_f64: i64(符号なし) を f64 へ変換

目的もくてき:

• 符号なし i64 を f64 に変換します。

実装じっそう:

• wasm は f64.convert_i64_u、llvm は uitofp i64 to double を使います。

注意ちゅうい:

• 大きな値では下位ビットが丸められます。

計算量けいさんりょう:

• O(1)

trunc_s_f64_to_i32: f64 を i32(符号付き)へ切り捨て変換

目的もくてき:

• f64 を 0 方向へ切り捨てて i32 に変換します。

実装じっそう:

• wasm は i32.trunc_f64_s、llvm は fptosi double to i32 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_u_f64_to_i32: f64 を i32(符号なし)へ切り捨て変換

目的もくてき:

• f64 を 0 方向へ切り捨てて i32 に変換します。

実装じっそう:

• wasm は i32.trunc_f64_u、llvm は fptoui double to i32 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_sat_s_f64_to_i32: f64 を i32(符号付き)へ飽和変換

目的もくてき:

• f64 を i32 に変換し、範囲外は最小値/最大値へ丸めます。

実装じっそう:

• wasm は i32.trunc_sat_f64_s を使います。
• llvm は llvm.fptosi.sat.i32.f64 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

trunc_sat_u_f64_to_i32: f64 を i32(符号なし)へ飽和変換

目的もくてき:

• f64 を i32 に変換し、範囲外は 0 か最大値へ丸めます。

実装じっそう:

• wasm は i32.trunc_sat_f64_u を使います。
• llvm は llvm.fptoui.sat.i32.f64 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

trunc_s_f64_to_i64: f64 を i64(符号付き)へ切り捨て変換

目的もくてき:

• f64 を 0 方向へ切り捨てて i64 に変換します。

実装じっそう:

• wasm は i64.trunc_f64_s、llvm は fptosi double to i64 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_u_f64_to_i64: f64 を i64(符号なし)へ切り捨て変換

目的もくてき:

• f64 を 0 方向へ切り捨てて i64 に変換します。

実装じっそう:

• wasm は i64.trunc_f64_u、llvm は fptoui double to i64 を使います。

注意ちゅうい:

• NaN や範囲外値は trap（未定義変換）になります。

計算量けいさんりょう:

• O(1)

trunc_sat_s_f64_to_i64: f64 を i64(符号付き)へ飽和変換

目的もくてき:

• f64 を i64 に変換し、範囲外は最小値/最大値へ丸めます。

実装じっそう:

• wasm は i64.trunc_sat_f64_s を使います。
• llvm は llvm.fptosi.sat.i64.f64 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

trunc_sat_u_f64_to_i64: f64 を i64(符号なし)へ飽和変換

目的もくてき:

• f64 を i64 に変換し、範囲外は 0 か最大値へ丸めます。

実装じっそう:

• wasm は i64.trunc_sat_f64_u を使います。
• llvm は llvm.fptoui.sat.i64.f64 intrinsic を使います。

注意ちゅうい:

• NaN は 0 になります。

計算量けいさんりょう:

• O(1)

promote_f32_to_f64: f32 を f64 へ拡張変換

目的もくてき:

• f32 値を精度の高い f64 へ拡張します。

実装じっそう:

• wasm は f64.promote_f32、llvm は fpext float to double を使います。

注意ちゅうい:

• 値は厳密に保持されます（f32 から f64 への拡張で情報は失われません）。

計算量けいさんりょう:

• O(1)

demote_f64_to_f32: f64 を f32 へ縮小変換

目的もくてき:

• f64 値を f32 へ縮小します。

実装じっそう:

• wasm は f32.demote_f64、llvm は fptrunc double to float を使います。

注意ちゅうい:

• 精度は失われる可能性があります。

計算量けいさんりょう:

• O(1)

reinterpret_i32_to_f32: i32 のビット列を f32 として再解釈

目的もくてき:

• 32-bit のビット列を変更せずに f32 として扱います。

実装じっそう:

• wasm は f32.reinterpret_i32、llvm は bitcast i32 to float を使います。

注意ちゅうい:

• 数値変換ではなくビット再解釈です。

計算量けいさんりょう:

• O(1)

reinterpret_f32_to_i32: f32 のビット列を i32 として再解釈

目的もくてき:

• f32 のビット表現をそのまま i32 として読み取ります。

実装じっそう:

• wasm は i32.reinterpret_f32、llvm は bitcast float to i32 を使います。

注意ちゅうい:

• 数値変換ではなくビット再解釈です。

計算量けいさんりょう:

• O(1)

reinterpret_i64_to_f64: i64 のビット列を f64 として再解釈

目的もくてき:

• 64-bit のビット列を変更せずに f64 として扱います。

実装じっそう:

• wasm は f64.reinterpret_i64、llvm は bitcast i64 to double を使います。

注意ちゅうい:

• 数値変換ではなくビット再解釈です。

計算量けいさんりょう:

• O(1)

reinterpret_f64_to_i64: f64 のビット列を i64 として再解釈

目的もくてき:

• f64 のビット表現をそのまま i64 として読み取ります。

実装じっそう:

• wasm は i64.reinterpret_f64、llvm は bitcast double to i64 を使います。

注意ちゅうい:

• 数値変換ではなくビット再解釈です。

計算量けいさんりょう:

• O(1)

extend_s: 符号拡張を行う

目的もくてき:

• 型名 prefix を使わずに符号拡張を呼び出せるようにします。

wrap: i64 を i32 へ切り詰める

目的もくてき:

• 型名 prefix を使わずに切り詰め変換を呼び出せるようにします。

convert_s: 符号付き整数を浮動小数へ変換する

目的もくてき:

• 変換関数を型オーバーロードで統一します。

trunc_s: 浮動小数を符号付き整数へ切り捨て変換する

目的もくてき:

• 切り捨て変換を型オーバーロードで統一します。

promote: f32 を f64 に拡張する
demote: f64 を f32 に縮小する
and: bool の論理積

目的もくてき:

• bool の a && b 相当を計算します。

実装じっそう:

• wasm は i32.and、llvm は and i32 を使います。

注意ちゅうい:

• bool は 0/1 前提です。

計算量けいさんりょう:

• O(1)

or: bool の論理和

目的もくてき:

• bool の a || b 相当を計算します。

実装じっそう:

• wasm は i32.or、llvm は or i32 を使います。

注意ちゅうい:

• bool は 0/1 前提です。

計算量けいさんりょう:

• O(1)

not: bool の否定

目的もくてき:

• bool の !a を計算します。

実装じっそう:

• wasm は i32.eqz、llvm は icmp eq を使います。

注意ちゅうい:

• bool は 0/1 前提です。

計算量けいさんりょう:

• O(1)

追加整数型 API（u32/u64/u128/i128）

目的もくてき:

• WASM ネイティブの i32/i64 を土台に、符号なし整数および 128-bit 相当の基本演算を提供します。

実装じっそう:

• u32/u64 は add/sub/mul/div_u/rem_u と lt_u/le_u/gt_u/ge_u を使います。
• u128/i128 は i64 2 ワード（上位/下位）で構成し、加減算と比較を実装します。

注意ちゅうい:

• u128/i128 の除算・乗算は未提供です（今後拡張）。

#entry main
#target core
#import "core/test" as *
#import "core/math" as *
#import "core/cast" as *
fn main <()*>()> ():
    assert_eq_i32 3 add 1 2;
    assert lt_u <i64> cast 9 <i64> cast 10;

u128: u128 相当（上位/下位 64-bit）
new: hi/lo から u128 値を構築する
to_u128: u64 値から u128 値を作る
add: u128 の加算（mod 2^128）
sub: u128 の減算（mod 2^128）
lt: u128 の大小比較（a < b）
i128: i128 相当（上位/下位 64-bit, 2 の補数）
new: hi/lo から i128 値を構築する
to_i128: i64 値を符号拡張して i128 に変換する
add: i128 の加算（mod 2^128）
sub: i128 の減算（mod 2^128）
mul_wide: u64 × u64 の 128-bit 積を返す

目的もくてき:

• 64-bit 乗算の上位 64-bit と下位 64-bit を同時に求めます。

実装じっそう:

• 入力を 32-bit 上位/下位に分割し、部分積を合成します。
• 途中の加算では lt_u でキャリーを検出します。

注意ちゅうい:

• 符号なし演算として扱います。

計算量けいさんりょう:

• O(1)

mul: i128 の乗算（mod 2^128）

目的もくてき:

• i128 同士の積の下位 128-bit を返します。

実装じっそう:

• a = a_hi*2^64 + a_lo, b = b_hi*2^64 + b_lo とみなし、

a_lo*b_lo の 128-bit 積と交差項 a_hi*b_lo, a_lo*b_hi を合成します。

注意ちゅうい:

• 2 の補数表現の mod 2^128 乗算です（オーバーフローはラップ）。

計算量けいさんりょう:

• O(1)

lt: i128 の大小比較（a < b）