vx-toolkit 1.16.2__py3-none-any.whl

vx_toolkit/_bin/std/iter.vx

@@ -0,0 +1,67 @@
+# ============================================================
+# std::iter —— 数组/Vec 通用迭代工具
+# 补充 Vec 未提供的 find / any / all / reduce
+# ============================================================
+
+import std.error
+import std.collections.vec
+
+class Iter:
+    # 查找第一个满足 pred 的元素，返回 Result
+    func find(arr: var, pred: var) -> var:
+        var i = 0
+        var n = len(arr)
+        while i < n:
+            if pred(arr[i]):
+                return Result.ok(arr[i])
+            i = i + 1
+        return Result.err(error.value_error("Iter.find: no matching element"))
+
+    # 是否存在满足 pred 的元素
+    func any(arr: var, pred: var) -> bool:
+        var i = 0
+        var n = len(arr)
+        while i < n:
+            if pred(arr[i]):
+                return true
+            i = i + 1
+        return false
+
+    # 是否所有元素都满足 pred
+    func all(arr: var, pred: var) -> bool:
+        var i = 0
+        var n = len(arr)
+        while i < n:
+            if pred(arr[i]) == false:
+                return false
+            i = i + 1
+        return true
+
+    # 从左到右归约
+    func reduce(arr: var, init: var, f: var) -> var:
+        var acc = init
+        var i = 0
+        var n = len(arr)
+        while i < n:
+            acc = f(acc, arr[i])
+            i = i + 1
+        return acc
+
+    # 将数组复制到新 Vec
+    func collect(arr: var) -> var:
+        var v = new Vec()
+        var i = 0
+        var n = len(arr)
+        while i < n:
+            v.push(arr[i])
+            i = i + 1
+        return v
+
+    # 反转数组得到新数组
+    func reversed(arr: var) -> var:
+        var result = []
+        var i = len(arr) - 1
+        while i >= 0:
+            result = result + [arr[i]]
+            i = i - 1
+        return result

vx_toolkit/_bin/std/macros.vx

@@ -0,0 +1,117 @@
+# ============================================================
+# std::macros —— 编译时宏工具库
+# 提供常用的代码生成模板，在编译阶段展开，零运行时开销
+# ============================================================
+# 使用方式：
+#   import std              # 通过 prelude 自动导入
+#   import std.macros       # 按需显式导入
+# ============================================================
+
+# ============================================================
+# 一、调试与日志宏
+# ============================================================
+
+# 断言：条件不成立时输出错误信息
+# 用法：#assert(x > 0, "x 必须为正数")
+macro assert(condition, message) {
+    if !condition {
+        out("Assertion failed: " + message)
+    }
+}
+
+# 调试打印：输出变量名与值
+# 用法：#debug_print("x", x)
+macro debug_print(name, value) {
+    out("DEBUG: " + name + " = " + value)
+}
+
+# 日志级别宏
+# 用法：#log_info("服务已启动")
+macro log_info(message) {
+    out("[INFO] " + message)
+}
+
+macro log_warn(message) {
+    out("[WARN] " + message)
+}
+
+macro log_error(message) {
+    out("[ERROR] " + message)
+}
+
+macro log_debug(message) {
+    out("[DEBUG] " + message)
+}
+
+# ============================================================
+# 二、控制流宏
+# ============================================================
+
+# 条件为真时执行
+# 用法：#when(flag, out("flag 为 true"))
+macro when(condition, action) {
+    if condition {
+        action
+    }
+}
+
+# 条件为假时执行
+# 用法：#unless(flag, out("flag 为 false"))
+macro unless(condition, action) {
+    if !condition {
+        action
+    }
+}
+
+# 重复执行 n 次
+# 用法：#repeat(3, out("Hello"))
+macro repeat(n, body) {
+    var __vx_macro_i = 0
+    while __vx_macro_i < n {
+        body
+        __vx_macro_i = __vx_macro_i + 1
+    }
+}
+
+# repeat 的别名
+macro times(n, body) {
+    var __vx_macro_i = 0
+    while __vx_macro_i < n {
+        body
+        __vx_macro_i = __vx_macro_i + 1
+    }
+}
+
+# ============================================================
+# 三、变量操作宏
+# ============================================================
+
+# 交换两个可赋值变量的值
+# 用法：#swap(a, b)
+# 注意：a、b 必须是可修改的左值（如变量、字段）
+macro swap(a, b) {
+    var __vx_macro_temp = a
+    a = b
+    b = __vx_macro_temp
+}
+
+# ============================================================
+# 四、Result 辅助宏
+# ============================================================
+
+# 确保 Result 成功，否则输出错误信息
+# 用法：#ensure_ok(result, "读取配置失败")
+macro ensure_ok(result, message) {
+    if !result.is_ok {
+        out("Error: " + message)
+    }
+}
+
+# 如果 Result 失败则直接返回该 Result
+# 用法：#try_return(read_file(path))
+# 注意：仅在返回 Result 的函数中使用
+macro try_return(result) {
+    if !result.is_ok {
+        return result
+    }
+}

vx_toolkit/_bin/std/math/math.vx

@@ -0,0 +1,341 @@
+# ============================================================
+# std::math —— 基础数学运算模块
+# ============================================================
+
+import std.collections.vec
+
+# ---- 数学常量 ----
+# 注：VX 当前无 const 关键字，使用函数返回常量值
+
+func math_pi() -> float:
+    return 3.141592653589793
+
+func math_e() -> float:
+    return 2.718281828459045
+
+func math_tau() -> float:
+    return 6.283185307179586
+
+func deg_to_rad() -> float:
+    return 0.017453292519943295
+
+func rad_to_deg() -> float:
+    return 57.29577951308232
+
+# ========== 基础函数 ==========
+
+func abs(x: float) -> float:
+    if x < 0.0:
+        return -x
+    return x
+
+func abs_int(x: int) -> int:
+    if x < 0:
+        return -x
+    return x
+
+func min(a: var, b: var) -> var:
+    if a < b:
+        return a
+    return b
+
+func max(a: var, b: var) -> var:
+    if a > b:
+        return a
+    return b
+
+func clamp(val: var, lo: var, hi: var) -> var:
+    if val < lo:
+        return lo
+    if val > hi:
+        return hi
+    return val
+
+func floor(x: float) -> int:
+    var i = x
+    if i > x:
+        i = i - 1
+    return i
+
+func ceil(x: float) -> int:
+    var i = x
+    if i < x:
+        i = i + 1
+    return i
+
+func round(x: float) -> int:
+    return floor(x + 0.5)
+
+func trunc(x: float) -> int:
+    if x >= 0.0:
+        return floor(x)
+    return ceil(x)
+
+func fract(x: float) -> float:
+    return x - floor(x)
+
+func sign(x: float) -> int:
+    if x > 0.0:
+        return 1
+    if x < 0.0:
+        return -1
+    return 0
+
+# ========== 幂/对数 ==========
+
+# 整数幂运算
+func pow_int(base: int, exp: int) -> int:
+    if exp < 0:
+        return 0
+    var result = 1
+    var i = 0
+    while i < exp:
+        result = result * base
+        i = i + 1
+    return result
+
+# 浮点幂运算（整数指数递归快速幂）
+func pow(base: float, exp: int) -> float:
+    if exp == 0:
+        return 1.0
+    if exp < 0:
+        return 1.0 / pow(base, -exp)
+    var half = pow(base, exp / 2)
+    if exp % 2 == 0:
+        return half * half
+    return half * half * base
+
+# 平方根（牛顿迭代法）
+func sqrt(x: float) -> float:
+    if x < 0.0:
+        return 0.0
+    if x == 0.0:
+        return 0.0
+    var guess = x
+    var i = 0
+    while i < 20:
+        guess = (guess + x / guess) / 2.0
+        i = i + 1
+    return guess
+
+# 立方根
+func cbrt(x: float) -> float:
+    if x == 0.0:
+        return 0.0
+    var neg = false
+    if x < 0.0:
+        neg = true
+        x = -x
+    var guess = x
+    var i = 0
+    while i < 30:
+        guess = (2.0 * guess + x / (guess * guess)) / 3.0
+        i = i + 1
+    if neg:
+        return -guess
+    return guess
+
+# e^x（泰勒级数）
+func exp(x: float) -> float:
+    var result = 1.0
+    var term = 1.0
+    var n = 1
+    while n < 20:
+        term = term * x / n
+        result = result + term
+        n = n + 1
+    return result
+
+# 自然对数 ln(x)（牛顿法）
+func ln(x: float) -> float:
+    if x <= 0.0:
+        return 0.0
+    if x == 1.0:
+        return 0.0
+    var guess = x - 1.0
+    var i = 0
+    while i < 20:
+        var exp_guess = exp(guess)
+        guess = guess + (x - exp_guess) / exp_guess
+        i = i + 1
+    return guess
+
+# 任意底对数
+func log(base: float, x: float) -> float:
+    return ln(x) / ln(base)
+
+func log2(x: float) -> float:
+    return ln(x) / 0.6931471805599453
+
+func log10(x: float) -> float:
+    return ln(x) / 2.302585092994046
+
+# ========== 三角函数（泰勒级数近似） ==========
+
+# 角度参数规约到 [-pi, pi]
+func _normalize_angle(x: float) -> float:
+    var pi = math_pi()
+    var two_pi = 2.0 * pi
+    while x > pi:
+        x = x - two_pi
+    while x < -pi:
+        x = x + two_pi
+    return x
+
+# 正弦（泰勒级数）
+func sin(x: float) -> float:
+    x = _normalize_angle(x)
+    var result = x
+    var term = x
+    var n = 1
+    while n < 10:
+        term = term * (-x * x) / ((2 * n) * (2 * n + 1))
+        result = result + term
+        n = n + 1
+    return result
+
+# 余弦
+func cos(x: float) -> float:
+    var pi = math_pi()
+    return sin(x + pi / 2.0)
+
+# 正切
+func tan(x: float) -> float:
+    var c = cos(x)
+    if c == 0.0:
+        return 0.0
+    return sin(x) / c
+
+# 反正弦（牛顿法 + 区间判断）
+func asin(x: float) -> float:
+    if x < -1.0:
+        return -math_pi() / 2.0
+    if x > 1.0:
+        return math_pi() / 2.0
+    if x == 0.0:
+        return 0.0
+    # 牛顿法求解 sin(y) - x = 0
+    var guess = x
+    var i = 0
+    while i < 10:
+        var s = sin(guess)
+        var c = cos(guess)
+        if c == 0.0:
+            return guess
+        guess = guess - (s - x) / c
+        i = i + 1
+    return guess
+
+# 反余弦
+func acos(x: float) -> float:
+    return math_pi() / 2.0 - asin(x)
+
+# 反正切
+func atan(x: float) -> float:
+    if x == 0.0:
+        return 0.0
+    # 用 asin 实现：atan(x) = asin(x / sqrt(1 + x²))
+    return asin(x / sqrt(1.0 + x * x))
+
+# atan2(y, x)
+func atan2(y: float, x: float) -> float:
+    if x > 0.0:
+        return atan(y / x)
+    if x < 0.0:
+        if y >= 0.0:
+            return atan(y / x) + math_pi()
+        return atan(y / x) - math_pi()
+    # x == 0
+    if y > 0.0:
+        return math_pi() / 2.0
+    if y < 0.0:
+        return -math_pi() / 2.0
+    return 0.0
+
+# 双曲正弦
+func sinh(x: float) -> float:
+    var ex = exp(x)
+    return (ex - 1.0 / ex) / 2.0
+
+# 双曲余弦
+func cosh(x: float) -> float:
+    var ex = exp(x)
+    return (ex + 1.0 / ex) / 2.0
+
+# 双曲正切
+func tanh(x: float) -> float:
+    if x == 0.0:
+        return 0.0
+    var sh = sinh(x)
+    var ch = cosh(x)
+    if ch == 0.0:
+        return 0.0
+    return sh / ch
+
+# ========== 数值检查 ==========
+
+func is_nan(x: float) -> bool:
+    # NaN 不等于自身
+    if x == x:
+        return false
+    return true
+
+func is_finite(x: float) -> bool:
+    if is_nan(x):
+        return false
+    if x == 1.0:
+        if x / 1000000000000000000000000000.0 == 0.0:
+            return true
+    return true
+
+# ========== 通用数学工具 ==========
+
+func hypot(x: float, y: float) -> float:
+    return sqrt(x * x + y * y)
+
+func lerp(a: float, b: float, t: float) -> float:
+    return a + (b - a) * t
+
+func gcd(a: int, b: int) -> int:
+    a = abs_int(a)
+    b = abs_int(b)
+    while b != 0:
+        var t = b
+        b = a % b
+        a = t
+    return a
+
+func lcm(a: int, b: int) -> int:
+    if a == 0:
+        if b == 0:
+            return 0
+        return abs_int(b)
+    return abs_int(a * b) / gcd(a, b)
+
+func is_prime(n: int) -> bool:
+    if n < 2:
+        return false
+    if n <= 3:
+        return true
+    if n % 2 == 0:
+        return false
+    if n % 3 == 0:
+        return false
+    var i = 5
+    while i * i <= n:
+        if n % i == 0:
+            return false
+        if n % (i + 2) == 0:
+            return false
+        i = i + 6
+    return true
+
+func factorial(n: int) -> int:
+    if n < 0:
+        return 0
+    var result = 1
+    var i = 2
+    while i <= n:
+        result = result * i
+        i = i + 1
+    return result

vx_toolkit/_bin/std/math/mod.vx

@@ -0,0 +1,6 @@
+# ============================================================
+# std::math —— 模块入口
+# ============================================================
+
+import std.math.math
+import std.math.random

vx_toolkit/_bin/std/math/random.vx

@@ -0,0 +1,104 @@
+# ============================================================
+# std::math::random —— 随机数生成
+# 使用 xoshiro256** 算法（简化版线性同余生成器）
+# ============================================================
+
+import std.math
+
+# ---- Random 类：伪随机数生成器 ----
+class Random:
+    seed: int           # 当前种子值
+    a: int              # 乘数 6364136223846793005
+    c: int              # 增量 1442695040888963407
+    m: int              # 模数 2^31 - 1
+
+    # 初始化（使用时钟种子）
+    func new() -> var:
+        var r = new Random()
+        # 默认种子（可通过 time 模块改进）
+        r.seed = 123456789
+        r.a = 636413622384679
+        r.c = 1442695040
+        r.m = 2147483647
+        return r
+
+    # 指定种子初始化（可复现随机序列）
+    func with_seed(seed: int) -> var:
+        var r = new Random()
+        r.seed = seed
+        r.a = 636413622384679
+        r.c = 1442695040
+        r.m = 2147483647
+        return r
+
+    # 生成下一个随机整数（LCG 算法）
+    func _next_int() -> int:
+        self.seed = (self.a * self.seed + self.c) % self.m
+        return self.seed
+
+    # 生成 [0, 1) 的浮点数
+    func next() -> float:
+        var r = self._next_int()
+        var m = self.m
+        return r / m
+
+    # 生成 [lo, hi] 的整数
+    func next_int(lo: int, hi: int) -> int:
+        if lo >= hi:
+            return lo
+        var range = hi - lo + 1
+        var r = self._next_int()
+        return lo + (r % range)
+
+    # 生成 [lo, hi) 的浮点数
+    func next_float(lo: float, hi: float) -> float:
+        if lo >= hi:
+            return lo
+        return lo + self.next() * (hi - lo)
+
+    # 正态分布（Box-Muller 变换）
+    func gaussian(mean: float, stddev: float) -> float:
+        var u1 = self.next()
+        if u1 == 0.0:
+            u1 = 0.000001
+        var u2 = self.next()
+        var z = sqrt(-2.0 * ln(u1)) * cos(2.0 * math_pi() * u2)
+        return mean + z * stddev
+
+    # 从列表中随机选择
+    func choice(items: var) -> var:
+        var n = len(items)
+        if n == 0:
+            return nil
+        var idx = self.next_int(0, n - 1)
+        return items[idx]
+
+    # 洗牌（Fisher-Yates）
+    func shuffle(items: var) -> var:
+        var n = len(items)
+        var result = []
+        var i = 0
+        while i < n:
+            result = result + [items[i]]
+            i = i + 1
+        i = n - 1
+        while i > 0:
+            var j = self.next_int(0, i)
+            var tmp = result[i]
+            result[i] = result[j]
+            result[j] = tmp
+            i = i - 1
+        return result
+
+    # 不放回抽样
+    func sample(items: var, k: int) -> var:
+        var n = len(items)
+        if k > n:
+            k = n
+        var shuffled = self.shuffle(items)
+        var result = []
+        var i = 0
+        while i < k:
+            result = result + [shuffled[i]]
+            i = i + 1
+        return result

vx_toolkit/_bin/std/mem/allocator.vx

@@ -0,0 +1,9 @@
+# ============================================================
+# std::mem.allocator —— 分配器接口
+# Zig 风格：显式分配/释放，无 hidden GC
+# ============================================================
+
+extern func malloc(size: int) -> int
+extern func c_free(ptr: int)
+extern func calloc(count: int, size: int) -> int
+extern func c_realloc(ptr: int, size: int) -> int

vx_toolkit/_bin/std/mem/arena.vx

@@ -0,0 +1,41 @@
+# ============================================================
+# std::mem.arena —— 竞技场分配器（ArenaAllocator）
+# Zig 风格：一次性分配、批量释放
+# ============================================================
+
+var arena_used: int = 0
+var arena_capacity: int = 0
+var arena_block_size: int = 65536
+var arena_blocks: var = []
+
+func arena_reset():
+    arena_used = 0
+    arena_capacity = 0
+    arena_blocks = []
+
+func arena_alloc(size: int) -> int:
+    if arena_used + size > arena_capacity:
+        var new_cap = arena_block_size
+        if size > new_cap:
+            new_cap = size
+        var block_ptr = malloc(new_cap)
+        arena_blocks = arena_blocks + [block_ptr]
+        arena_capacity = new_cap
+        arena_used = 0
+    var last_block = arena_blocks[len(arena_blocks) - 1]
+    var ptr = last_block + arena_used
+    arena_used = arena_used + size
+    return ptr
+
+func arena_dealloc(ptr: int):
+    # 竞技场不支持单块释放
+
+func arena_free_all():
+    var i = 0
+    while i < len(arena_blocks):
+        c_free(arena_blocks[i])
+        i = i + 1
+    arena_reset()
+
+func arena_allocated() -> int:
+    return arena_used