@mirascript/mirascript 0.1.76 → 0.1.79

package/src/vm/lib/global/sequence/new.ts

@@ -1,7 +1,13 @@
 import type { VmArray, VmConst, VmRecord } from '../../../types/index.js';
-import { toString } from '../../../../helpers/convert/to-string.js';
+import { toString } from '../../../../helpers/convert/index.js';
 import { VM_ARRAY_MAX_LENGTH } from '../../../../helpers/constants.js';
-import { keys as _keys, values as _values, entries as _entries, PositiveInfinity } from '../../../../helpers/utils.js';
+import {
+    keys as _keys,
+    values as _values,
+    entries as _entries,
+    PositiveInfinity,
+    setRecord,
+} from '../../../../helpers/utils.js';
 import { $Call, $El, $Get } from '../../../operations/index.js';
 import { VmLib, expectCallable, expectIntegerRange } from '../../helpers.js';
 
@@ -15,7 +21,7 @@ export const new_record = VmLib(
             if (entry == null) continue;
             const key = $Get(entry, 0);
             const value = $El($Get(entry, 1));
-            result[toString(key)] = value;
+            setRecord(result, toString(key), value);
         }
         return result;
     },

package/src/vm/lib/global/sequence/sort.ts

@@ -1,4 +1,4 @@
-import { toNumber } from '../../../../helpers/convert/to-number.js';
+import { toNumber } from '../../../../helpers/convert/index.js';
 import { $Call } from '../../../operations/index.js';
 import type { VmAny, VmConst, VmValue } from '../../../types/index.js';
 import { VmLib, expectArray, expectCallable } from '../../helpers.js';

package/src/vm/lib/global/sequence/unique.ts

@@ -1,4 +1,4 @@
-import { toBoolean } from '../../../../helpers/convert/to-boolean.js';
+import { toBoolean } from '../../../../helpers/convert/index.js';
 import { $Call } from '../../../operations/call.js';
 import { isSame } from '../../../operations/utils.js';
 import type { VmAny, VmConst, VmValue } from '../../../types/index.js';

package/src/vm/lib/global/sequence/with.ts

@@ -1,7 +1,7 @@
 import { VM_ARRAY_MAX_LENGTH } from '../../../../helpers/constants.js';
 import { toNumber, toString } from '../../../../helpers/convert/index.js';
-import { isVmArray, isVmRecord } from '../../../../helpers/types.js';
-import { isArray, isInteger, isFinite, NotNumber } from '../../../../helpers/utils.js';
+import { isVmArray, isVmRecord } from '../../../../helpers/types/index.js';
+import { isArray, isInteger, isFinite, NotNumber, setRecord, getRecord } from '../../../../helpers/utils.js';
 import { $El } from '../../../operations/helpers.js';
 import type { VmArray, VmConst, VmValue } from '../../../types/index.js';
 import { VmLib, expectArrayOrRecord, expectConst, throwError } from '../../helpers.js';
@@ -46,7 +46,7 @@ const withInner = (obj: VmConst | undefined, key: VmArray, keyIndex: number, val
         result[index] = withInner(result[index], key, keyIndex + 1, value);
     } else {
         const prop = toString(k, undefined);
-        result[prop] = withInner(result[prop], key, keyIndex + 1, value);
+        setRecord(result, prop, withInner(result[prop], key, keyIndex + 1, value));
     }
     return result;
 };
@@ -110,12 +110,12 @@ const _with = VmLib(
                 if (isVmArray(key)) {
                     const firstKey = key[0]!;
                     prop = toString(firstKey, undefined);
-                    val = withInner(result[prop], key, 1, value);
+                    val = withInner(getRecord(result, prop), key, 1, value);
                 } else {
                     prop = toString(key, undefined);
                     val = value;
                 }
-                result[prop] = val;
+                setRecord(result, prop, val);
             }
             return result;
         }

package/src/vm/lib/global/sequence/zip.ts

@@ -1,12 +1,13 @@
 import { display } from '../../../../helpers/serialize.js';
+import { setRecord } from '../../../../helpers/utils.js';
 import { Cp } from '../../../checkpoint.js';
-import { isVmArray, type VmConst, type VmArray } from '../../../types/index.js';
+import { isVmArray, type VmConst, type VmArray, type VmRecord } from '../../../types/index.js';
 import { VmLib, throwError } from '../../helpers.js';
 import { entries } from './entries.js';
 
 export const zip = VmLib(
     (data) => {
-        const ets = entries(data);
+        const ets = entries(data) as Array<{ 0: string | number; 1: VmArray }>;
         let length = 0;
         for (const { 0: key, 1: arr } of ets) {
             if (!isVmArray(arr)) {
@@ -15,15 +16,25 @@ export const zip = VmLib(
             length = Math.max(length, arr.length);
         }
         if (length === 0) return [];
-        const result: Array<Record<number | string, VmConst>> = [];
-        const isArr = isVmArray(data);
-        for (let i = 0; i < length; i++) {
-            Cp();
-            const obj: Record<number | string, VmConst> = isArr ? ([] as Record<number, VmConst>) : {};
-            for (const { 0: key, 1: arr } of ets) {
-                obj[key] = (arr as VmArray)[i] ?? null;
+        const result: Array<VmArray | VmRecord> = [];
+        if (isVmArray(data)) {
+            for (let i = 0; i < length; i++) {
+                Cp();
+                const obj: VmConst[] = [];
+                for (const { 0: key, 1: arr } of ets) {
+                    obj[key as number] = arr[i] ?? null;
+                }
+                result.push(obj);
+            }
+        } else {
+            for (let i = 0; i < length; i++) {
+                Cp();
+                const obj: Record<string, VmConst> = {};
+                for (const { 0: key, 1: arr } of ets) {
+                    setRecord(obj, key as string, arr[i]);
+                }
+                result.push(obj);
             }
-            result.push(obj);
         }
         return result;
     },

package/src/vm/lib/global/time.ts

@@ -1,6 +1,6 @@
 import { describeParam, expectNumberRange, throwError, throwUnexpectedTypeError, VmLib } from '../helpers.js';
 import { isNaN, NotNumber, isFinite } from '../../../helpers/utils.js';
-import { toNumber } from '../../../helpers/convert/to-number.js';
+import { toNumber } from '../../../helpers/convert/index.js';
 import { display } from '../../../helpers/serialize.js';
 import type { VmAny } from '../../types/index.js';
 

package/src/vm/lib/helpers.ts

@@ -2,7 +2,14 @@ import { VM_ARRAY_MAX_LENGTH } from '../../helpers/constants.js';
 import { NotNumber, entries, fromEntries, isSafeInteger, isFinite } from '../../helpers/utils.js';
 import { toBoolean, toNumber, toString } from '../../helpers/convert/index.js';
 import { display } from '../../helpers/serialize.js';
-import { isVmArray, isVmFunction, isVmPrimitive, isVmConst, isVmCallable, isVmRecord } from '../../helpers/types.js';
+import {
+    isVmArray,
+    isVmFunction,
+    isVmPrimitive,
+    isVmConst,
+    isVmCallable,
+    isVmRecord,
+} from '../../helpers/types/index.js';
 import { VmError } from '../../helpers/error.js';
 import type {
     VmExtern,
@@ -240,10 +247,10 @@ export function arrayLen(len: number | null | undefined): number {
 }
 
 /** 应用映射函数 */
-export function map(
-    data: VmConst,
+export function iterate<T extends VmConst>(
+    data: T,
     /** 返回 `undefined` 表示跳过该元素 */
-    mapper: (value: VmConst, index: number | string | null, data: VmConst) => VmConst | undefined,
+    mapper: (value: VmConst, index: number | string | null, data: T) => VmConst | undefined,
 ): VmConst {
     if (isVmPrimitive(data)) {
         return mapper(data, null, data) ?? null;
@@ -260,7 +267,7 @@ export function map(
         return result;
     } else {
         const e: Array<[string, VmConst]> = [];
-        for (const [key, value] of entries(data)) {
+        for (const [key, value] of entries<string, VmConst | undefined>(data)) {
             Cp();
             const ret = mapper(value ?? null, key, data);
             if (ret === undefined) continue;

package/src/vm/lib/mod/index.ts

@@ -1 +1 @@
-export * as matrix from './matrix.js';
+export * as matrix from './matrix/index.js';

package/src/vm/lib/mod/matrix/bin-ops.ts

@@ -0,0 +1,291 @@
+import { Cp } from '../../../checkpoint.js';
+import { $Add, $Call, $Div, $Mul, $Sub } from '../../../operations/index.js';
+import { isVmConst, type VmConst } from '../../../types/index.js';
+import { VmLib, expectCallable, expectConst, throwError } from '../../helpers.js';
+import { num, size } from './helpers.js';
+const { max } = Math;
+
+/** 逐项操作 */
+function entrywiseImpl(
+    a: VmConst,
+    b: VmConst,
+    f: (a: VmConst, b: VmConst) => VmConst,
+    vvf?: (va: readonly VmConst[], vb: readonly VmConst[], ar: number, br: number) => VmConst,
+    mmf?: (
+        ma: readonly VmConst[][],
+        mb: readonly VmConst[][],
+        ar: number,
+        ac: number,
+        br: number,
+        bc: number,
+    ) => VmConst,
+    vmf?: (va: readonly VmConst[], mb: readonly VmConst[][], al: number, br: number, bc: number) => VmConst,
+    mvf?: (ma: readonly VmConst[][], vb: readonly VmConst[], ar: number, ac: number, bl: number) => VmConst,
+): VmConst {
+    let [ar, ac] = size(a);
+    let [br, bc] = size(b);
+
+    if (ar == null) {
+        if (br == null) {
+            // s/s
+            return f(a, b);
+        } else if (bc == null) {
+            // s/v
+            const result: VmConst[] = [];
+            for (let r = 0; r < br; r++) {
+                const bItem = (b as VmConst[])[r] ?? null;
+                result[r] = f(a, bItem);
+            }
+            return result;
+        } else {
+            // s/m
+            const result: VmConst[][] = [];
+            for (let r = 0; r < br; r++) {
+                const bRow = (b as VmConst[][])[r] ?? [];
+                const rRow: VmConst[] = [];
+                result[r] = rRow;
+                for (let c = 0; c < bc; c++) {
+                    const bItem = bRow[c] ?? null;
+                    rRow[c] = f(a, bItem);
+                }
+            }
+            return result;
+        }
+    }
+    if (br == null) {
+        if (ac == null) {
+            // v/s
+            const result: VmConst[] = [];
+            for (let r = 0; r < ar; r++) {
+                const aItem = (a as VmConst[])[r] ?? null;
+                result[r] = f(aItem, b);
+            }
+            return result;
+        } else {
+            // m/s
+            const result: VmConst[][] = [];
+            for (let r = 0; r < ar; r++) {
+                const aRow = (a as VmConst[][])[r] ?? [];
+                const rRow: VmConst[] = [];
+                result[r] = rRow;
+                for (let c = 0; c < ac; c++) {
+                    const aItem = aRow[c] ?? null;
+                    rRow[c] = f(aItem, b);
+                }
+            }
+            return result;
+        }
+    }
+    if (ac == null && bc == null) {
+        // v/v
+        if (vvf != null) {
+            return vvf(a as VmConst[], b as VmConst[], ar, br);
+        }
+        const rr = max(ar, br);
+        const result: VmConst[] = [];
+        for (let r = 0; r < rr; r++) {
+            const aItem = (a as VmConst[])[r] ?? null;
+            const bItem = (b as VmConst[])[r] ?? null;
+            result[r] = f(aItem, bItem);
+        }
+        return result;
+    }
+
+    // m/m (m/v v/m)
+    if (ac == null) {
+        // v/m
+        if (vmf != null) {
+            return vmf(a as VmConst[], b as VmConst[][], ar, br, bc!);
+        }
+        ac = ar!;
+        ar = 1;
+        a = [a];
+    }
+    if (bc == null) {
+        // m/v
+        if (mvf != null) {
+            return mvf(a as VmConst[][], b as VmConst[], ar, ac, br);
+        }
+        bc = br!;
+        br = 1;
+        b = [b];
+    }
+
+    if (mmf != null) {
+        return mmf(a as VmConst[][], b as VmConst[][], ar, ac, br, bc);
+    }
+    const rr = max(ar, br);
+    const rc = max(ac, bc);
+    const result: VmConst[][] = [];
+    for (let r = 0; r < rr; r++) {
+        const rRow: VmConst[] = [];
+        result[r] = rRow;
+        for (let c = 0; c < rc; c++) {
+            const aItem = (a as VmConst[][])[ar === 1 ? 0 : r]?.[ac === 1 ? 0 : c] ?? null;
+            const bItem = (b as VmConst[][])[br === 1 ? 0 : r]?.[bc === 1 ? 0 : c] ?? null;
+            rRow[c] = f(aItem, bItem);
+        }
+    }
+    return result;
+}
+
+export const entrywise = VmLib(
+    (a, b, f) => {
+        expectConst('a', a, null);
+        expectConst('b', b, null);
+        expectCallable('f', f, null);
+        return entrywiseImpl(a, b, (a, b) => {
+            Cp();
+            const ret = $Call(f, [a, b]);
+            if (!isVmConst(ret)) return null;
+            return ret;
+        });
+    },
+    {
+        summary: '逐项操作',
+        params: {
+            a: { type: 'any | any[] | any[][]', description: '第一个操作数' },
+            b: { type: 'any | any[] | any[][]', description: '第二个操作数' },
+            f: { type: 'fn(a: any, b: any) -> any', description: '操作函数' },
+        },
+        returns: { type: 'any | any[] | any[][]' },
+        examples: [`matrix.entrywise([1, 2], [3, 4], fn (x, y) { x + y }) // [4, 6]`],
+    },
+);
+
+export const add = VmLib(
+    (a, b) => {
+        expectConst('a', a, null);
+        expectConst('b', b, null);
+        return entrywiseImpl(a, b, $Add);
+    },
+    {
+        summary: '逐项相加',
+        params: {
+            a: { type: 'number | number[] | number[][]', description: '第一个操作数' },
+            b: { type: 'number | number[] | number[][]', description: '第二个操作数' },
+        },
+        returns: { type: 'number | number[] | number[][]' },
+        examples: ['matrix.add([1, 2], [3, 4]) // [4, 6]'],
+    },
+);
+
+export const subtract = VmLib(
+    (a, b) => {
+        expectConst('a', a, null);
+        expectConst('b', b, null);
+        return entrywiseImpl(a, b, $Sub);
+    },
+    {
+        summary: '逐项相减',
+        params: {
+            a: { type: 'number | number[] | number[][]', description: '第一个操作数' },
+            b: { type: 'number | number[] | number[][]', description: '第二个操作数' },
+        },
+        returns: { type: 'number | number[] | number[][]' },
+        examples: ['matrix.subtract([3, 4], [1, 2]) // [2, 2]'],
+    },
+);
+
+export const entrywise_multiply = VmLib(
+    (a, b) => {
+        expectConst('a', a, null);
+        expectConst('b', b, null);
+        return entrywiseImpl(a, b, $Mul);
+    },
+    {
+        summary: '逐项相乘',
+        params: {
+            a: { type: 'number | number[] | number[][]', description: '第一个操作数' },
+            b: { type: 'number | number[] | number[][]', description: '第二个操作数' },
+        },
+        returns: { type: 'number | number[] | number[][]' },
+        examples: ['matrix.entrywise_multiply([1, 2], [3, 4]) // [3, 8]'],
+    },
+);
+
+export const entrywise_divide = VmLib(
+    (a, b) => {
+        expectConst('a', a, null);
+        expectConst('b', b, null);
+        return entrywiseImpl(a, b, $Div);
+    },
+    {
+        summary: '逐项相除',
+        params: {
+            a: { type: 'number | number[] | number[][]', description: '第一个操作数' },
+            b: { type: 'number | number[] | number[][]', description: '第二个操作数' },
+        },
+        returns: { type: 'number | number[] | number[][]' },
+        examples: ['matrix.entrywise_divide([4, 6], [2, 3]) // [2, 2]'],
+    },
+);
+
+export const multiply = VmLib(
+    (a, b) => {
+        expectConst('a', a, null);
+        expectConst('b', b, null);
+        return entrywiseImpl(
+            a,
+            b,
+            $Mul,
+            (a, b, al, bl) => {
+                const l = max(al, bl);
+                let s = 0;
+                for (let i = 0; i < l; i++) {
+                    s += num(a[i]) * num(b[i]);
+                }
+                return s;
+            },
+            (a, b, ar, ac, br, bc) => {
+                if (ac !== br) throwError(`Incompatible matrix dimensions`, null);
+                const result: VmConst[][] = [];
+                for (let r = 0; r < ar; r++) {
+                    const rRow: VmConst[] = [];
+                    result[r] = rRow;
+                    for (let c = 0; c < bc; c++) {
+                        let item = 0;
+                        for (let k = 0; k < ac; k++) {
+                            item += num((a as VmConst[][])[r]?.[k]) * num((b as VmConst[][])[k]?.[c]);
+                        }
+                        rRow[c] = item;
+                    }
+                }
+                return result;
+            },
+            (a, b, al, br, bc) => {
+                if (al !== br) throwError(`Incompatible matrix dimensions`, null);
+                const result: VmConst[] = [];
+                for (let c = 0; c < bc; c++) {
+                    let item = 0;
+                    for (let k = 0; k < al; k++) {
+                        item += num(a[k]) * num((b as VmConst[][])[k]?.[c]);
+                    }
+                    result[c] = item;
+                }
+                return result;
+            },
+            (a, b, ar, ac, bl) => {
+                if (ac !== bl) throwError(`Incompatible matrix dimensions`, null);
+                const result: VmConst[] = [];
+                for (let r = 0; r < ar; r++) {
+                    let item = 0;
+                    for (let k = 0; k < ac; k++) {
+                        item += num((a as VmConst[][])[r]?.[k]) * num(b[k]);
+                    }
+                    result[r] = item;
+                }
+                return result;
+            },
+        );
+    },
+    {
+        summary: '矩阵相乘',
+        params: {
+            a: { type: 'number | number[] | number[][]', description: '第一个操作数' },
+            b: { type: 'number | number[] | number[][]', description: '第二个操作数' },
+        },
+        returns: { type: 'number | number[] | number[][]' },
+        examples: ['matrix.multiply([[1, 2], [3, 4]], [5, 6]) // [17, 39]'],
+    },
+);

package/src/vm/lib/mod/matrix/fill.ts

@@ -0,0 +1,109 @@
+import { isArray } from '../../../../helpers/utils.js';
+import { Cp } from '../../../checkpoint.js';
+import type { VmAny, VmArray, VmConst } from '../../../types/index.js';
+import { VmLib, expectArray, throwError, getNumbers, arrayLen, expectInteger } from '../../helpers.js';
+
+/** 填充 */
+function filled(size: readonly VmAny[], value: VmConst): VmArray {
+    const s = getNumbers(size);
+    if (s.length === 0) return [];
+    while (s.length > 0) {
+        const repeat = arrayLen(s.pop());
+        Cp();
+        const data: VmConst[] = [];
+        data.length = repeat;
+        // 从 MiraScript 语义而言，可以使用同一个引用
+        data.fill(value);
+        value = data;
+    }
+    return value as VmArray;
+}
+
+export const zeros = VmLib((...size) => filled(size, 0), {
+    summary: '创建一个全零的矩阵',
+    params: { '..size': { type: 'number[]', description: '矩阵的维度' } },
+    returns: { type: 'number[][]' },
+    examples: ['matrix.zeros(2, 3) // [[0, 0, 0], [0, 0, 0]]'],
+});
+
+export const ones = VmLib((...size) => filled(size, 1), {
+    summary: '创建一个全一的矩阵',
+    params: { '..size': { type: 'number[]', description: '矩阵的维度' } },
+    returns: { type: 'number[][]' },
+    examples: ['matrix.ones(2, 2) // [[1, 1], [1, 1]]'],
+});
+
+export const identity = VmLib(
+    (...size) => {
+        let s = getNumbers(size);
+        if (s.length === 0) return [];
+        if (s.length > 2) throwError('Invalid matrix size', []);
+        if (s.length === 1) s = [s[0]!, s[0]!];
+        const m = arrayLen(s[0]);
+        const n = arrayLen(s[1]);
+        // 由于 `filled` 函数返回只读数组，其每行为相同引用，这里需要手动创建每行
+        const ret: number[][] = [];
+        for (let i = 0; i < m; i++) {
+            const row: number[] = [];
+            ret[i] = row;
+            row.length = n;
+            row.fill(0);
+            if (i < n) row[i] = 1;
+        }
+        return ret;
+    },
+    {
+        summary: '创建一个单位矩阵',
+        params: { '..size': { type: '[number] | [number, number]', description: '矩阵的维度' } },
+        returns: { type: 'number[][]' },
+        examples: ['matrix.identity(3) // [[1, 0, 0], [0, 1, 0], [0, 0, 1]]'],
+    },
+);
+
+export const diagonal = VmLib(
+    (x, k = 0) => {
+        expectArray('x', x, []);
+        const fk = expectInteger('k', k);
+        if (x.every((e) => isArray(e))) {
+            // 获取对角线元素
+            const diag: VmConst[] = [];
+            for (let i = 0; i < x.length; i++) {
+                const row = x[i] as VmArray | undefined;
+                const r = i + fk;
+                if (r < 0) continue;
+                if (!row || r >= row.length) break;
+                diag.push(row[r] ?? null);
+            }
+            return diag;
+        }
+        // 创建对角矩阵
+        const l = x.length;
+        const m = arrayLen(fk < 0 ? l - fk : l);
+        const n = arrayLen(fk > 0 ? l + fk : l);
+        const result: VmConst[][] = [];
+        for (let i = 0; i < m; i++) {
+            const row: VmConst[] = [];
+            result[i] = row;
+            row.length = n;
+            row.fill(0);
+            for (let j = 0; j < n; j++) {
+                if (i + fk === j) {
+                    row[j] = x[fk >= 0 ? i : j] ?? null;
+                }
+            }
+        }
+        return result;
+    },
+    {
+        summary: '创建一个对角矩阵或获取矩阵的对角线',
+        params: {
+            x: { type: 'number[] | number[][]', description: '对角线元素或要获取对角线的矩阵' },
+            k: { type: 'number', description: '对角线偏移量，默认为 0' },
+        },
+        returns: { type: 'number[][] | number[]' },
+        examples: [
+            'matrix.diagonal([1, 2, 3]) // [[1, 0, 0], [0, 2, 0], [0, 0, 3]]',
+            'matrix.diagonal([[1, 2], [3, 4]]) // [1, 4]',
+        ],
+    },
+);

package/src/vm/lib/mod/matrix/helpers.ts

@@ -0,0 +1,26 @@
+import { toNumber } from '../../../../helpers/convert/index.js';
+import { isVmArray, type VmConst, type VmValue } from '../../../types/index.js';
+
+/** 计算尺寸 */
+export function size(matrix: VmValue): [] | [number] | [number, number] {
+    if (!isVmArray(matrix)) return [];
+    if (matrix.length === 0) return [0];
+
+    const numRows = matrix.length;
+    let numCols = 0;
+
+    for (const row of matrix) {
+        if (isVmArray(row)) {
+            numCols = Math.max(numCols, row.length);
+        } else {
+            return [numRows];
+        }
+    }
+
+    return [numRows, numCols];
+}
+
+/** 数组元素转为 number */
+export function num(v: VmConst | undefined): number {
+    return toNumber(v, undefined);
+}

package/src/vm/lib/mod/matrix/index.ts

@@ -0,0 +1,5 @@
+export * from './bin-ops.js';
+export * from './fill.js';
+export * from './invert.js';
+export * from './size.js';
+export * from './transpose.js';