var fraction = 16 / 9;           // 结果为 16/9，不是 1.777...
var result = fraction;

// 多次循环运算保持精确
var i = 1;
while (i <= 10) {
    result = result * 9 / 9;     // 始终保持为 16/9
    i = i + 1;
}

var root2 = sqrt(2);             // 精确的 √2
var root8 = sqrt(8);             // 自动化简为 2√2
var pi_val = pi();               // 精确的 π
var result = root2 * root2;      // 精确结果：2

// 传统浮点数（其他语言）
// 0.1 + 0.2 = 0.30000000000000004

// Lamina 精确计算
var result = 1/10 + 2/10;        // 结果：3/10（完全精确）

// 精确数学计算
print("Hello, Lamina!");
var fraction = 16 / 9;          // 精确分数，不是浮点数
print("16/9 =", fraction);      // 输出: 16/9

var root = sqrt(2);             // 精确无理数
print("√2 =", root);            // 输出: √2
print("√2 × √2 =", root * root);// 输出: 2（精确结果）

// 向量运算
var v1 = [1, 2, 3];
var v2 = [4, 5, 6];
print("v1 + v2 =", v1 + v2);
print("v1 · v2 =", dot(v1, v2));

// 精确常数
var pi_val = pi();
print("π =", pi_val);           // 输出: π（符号形式）

var x = 10;           //  正确
print(x);             //  正确
bigint big = 100!;    //  正确

var y = 20            //  错误：缺少分号
print(y)              //  错误：缺少分号

include "math_utils";     //  正确：使用引号包裹
include "lib/vectors";    //  正确：支持相对路径

include math_utils;       //  错误：必须使用引号

var func if else while for return break continue
print true false null include define bigint input
assert struct

// 单行注释
/* 块注释 */

var x = 10;
var name = "Alice";
var arr = [1, 2, 3];
bigint large_num = 999999999999;  // 大整数需显式声明
bigint factorial_result = 25!;    // 可直接从运算结果赋值

// 数组
var arr = [1, 2, 3];
var matrix = [[1,2], [3,4]];     // 2x2矩阵

// 函数
func add(a, b) {
    return a + b;
}

var v1 = [1, 2, 3];
var v2 = [4, 5, 6];

print(v1 + v2);                 // 向量加法：[5, 7, 9]
print(dot(v1, v2));             // 点积：32
print(2 * v1);                  // 标量乘法：[2, 4, 6]

struct Student{
    name = "Tom";
    age  =  10;
}

struct otherInfo{
    country = "US";
}

// 精确分数运算
print("=== 精确分数运算 ===");
var fraction = 16 / 9;           // 精确分数 16/9
print("16/9 =", fraction);

// 多次循环保持精确性
var result = fraction;
var i = 1;
while (i <= 5) {
    result = result * 9 / 9;     // 应该保持为 16/9
    print("第", i, "次循环:", result);
    i = i + 1;
}

// 精确无理数运算
print("\n=== 精确无理数运算 ===");
var root2 = sqrt(2);             // 精确的 √2
var root3 = sqrt(3);             // 精确的 √3
print("√2 =", root2);
print("√3 =", root3);
print("√2 + √3 =", root2 + root3);
print("√2 × √3 =", root2 * root3);
print("√2 × √2 =", root2 * root2);

// 精确常数
var pi_val = pi();
var e_val = e();
print("π =", pi_val);
print("e =", e_val);
print("π + e =", pi_val + e_val);

// 小数转分数
print("=== 小数转分数 ===");
print("0.5 =", fraction(0.5));      // 1/2
print("0.25 =", fraction(0.25));    // 1/4
print("0.75 =", fraction(0.75));    // 3/4
print("0.125 =", fraction(0.125));  // 1/8
print("0.625 =", fraction(0.625));  // 5/8

// 分数转小数
print("\n=== 分数转小数 ===");
print("1/2 =", decimal(1/2));       // 0.5
print("3/4 =", decimal(3/4));       // 0.75
print("1/3 =", decimal(1/3));       // 0.333333
print("2/3 =", decimal(2/3));       // 0.666667

// 精确计算的优势
print("\n=== 精确计算 vs 浮点计算 ===");
var float_result = 0.1 + 0.2;
var exact_result = fraction(0.1) + fraction(0.2);
print("浮点计算: 0.1 + 0.2 =", float_result);
print("精确计算: 1/10 + 1/5 =", exact_result);
print("转为小数:", decimal(exact_result));

func quadratic(a, b, c) {
    var discriminant = b^2 - 4*a*c;
    if (discriminant < 0) {
        print("Complex roots not supported");
        return null;
    } else {
        var root1 = (-b + sqrt(discriminant))/(2*a);
        var root2 = (-b - sqrt(discriminant))/(2*a);
        return [root1, root2];
    }
}

var roots = quadratic(1, -3, 2);
print("Roots:", roots);  // 输出 [2, 1]

// 直接计算
bigint result = 25!;
print("25! =", result);

// 递归版本
func factorial_big(n) {
    if (n <= 1) return 1;
    return n * factorial_big(n - 1);
}

bigint fact10 = factorial_big(10);
print("10! =", fact10);

// 向量运算
var v1 = [1, 2, 3];
var v2 = [4, 5, 6];
var v3 = [1, 0, 0];
var v4 = [0, 1, 0];

print("向量加法:", v1 + v2);
print("点积:", dot(v1, v2));
print("叉积:", cross(v3, v4));
print("模长:", norm(v1));

// 矩阵运算
var matrix = [[1, 2], [3, 4]];
print("行列式:", det(matrix));

// 包含数学工具模块
include "math_utils";

// 包含向量计算模块
include "vectors";

// 使用模块中定义的函数
var result = advanced_calculation(10, 20);
var vec = create_vector(1, 2, 3);

// 显示启动画面
include "splash";

Traceback (most recent call last):
  File "script.lm", line 12, in level1
  File "script.lm", line 8, in level2
  File "script.lm", line 4, in level3
RuntimeError: Undefined variable 'unknown_variable'