# @d4c/numjs 中文文档

规范地址：https://npmcn.com/package/%40d4c/numjs/

版本：0\.17\.35
npm 元数据更新时间：2026-03-07T12:50:16.825Z
中文译文更新时间：2026-11-11T09:17:34.793Z
软件包许可：MIT

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/%40d4c/numjs
原文对照：https://npmcn.com/package/%40d4c/numjs/?lang=original
项目主页：https://grimmerk.github.io/numjs
源码仓库：https://github.com/grimmerk/numjs

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：753 kB，33 个文件
- 模块格式：ESM + CJS
- TypeScript 类型：包内自带
- Node.js 要求：\>=20
- 运行依赖：7 个
- 首次发布：2021-11-07T16:54:41.992Z
- 最新版本发布：2026-03-07T12:50:16.667Z
- 近 30 天下载量：2492（2026-10-11 至 2026-11-09，npm 官方下载统计）
- 已发布版本数：36（近 12 个月 1 个）

## 中文简介

像 NumPy, 在 TypeScript 和 JavaScript 中

## 安装

```sh
npm install @d4c/numjs
```

也可以使用：`pnpm add @d4c/numjs`、`yarn add @d4c/numjs`、`bun add @d4c/numjs`

## README

# @d4c/numjs (韩语)

[![npm version](https://img.shields.io/npm/v/%40d4c/numjs.svg)](https://www.npmjs.com/package/@d4c/numjs) ![example workflow](https://github.com/grimmerk/numjs/actions/workflows/node.js.yml/badge.svg)

> **维持状况:** 这个项目在 **被动维修** 模式 —— 关键bug修正和小改进可能被接受,但没有计划活动特性开发.
> 
> 这么说, `@d4c/numjs` 现为a **稳定、随时使用** 类似 NumPy 的库,在框外有 TypeScript 的打字功能——如果你需要基本的 ndarray 操作而不处理不稳定的 API 或陡峭的学习曲线,它仍然很有效.
> 
> 关于更全面的替代办法,考虑:
> 
> -   [数字](https://github.com/nicktakpk/numpy-ts) ——旨在以纯类型脚本覆盖NumPy94%的API(仍处于早期/不稳定阶段)
> -   [@stdlib/ndaray (英语)](https://github.com/stdlib-js/ndarray) ——成熟而严谨,但具有不同的API风格

**数字Js** 建在顶部 [无线](https://scijs.net/packages/#scijs/ndarray) 并使用许多 [scijs 软件包](https://scijs.net/packages/)。 。 。 . `ndarray` 导出为 `nj.ndarray`,以及任意 `NdArray` 实例的财产 `selection` 是一个 `ndarray` 对象.

此项目修改自 [https://github.com/nicolaspanel/numjs (中文(简体) )](https://github.com/nicolaspanel/numjs) 并在修改后进行

-   删除图像操作的特性,其依赖性可能导致Mac M1 ARM机上的某些安装故障. 你可以考虑 [ndarray- 像素](https://github.com/donmccurdy/ndarray-pixels) 如果您需要这个功能.
-   添加类型脚本打字和 `.d.ts` 已退出框, JavaScript 也被支持。 而且,它包括
    -   ES6构建(ES-2015),为主建包. json.
    -   ES6构建(ES2015),为模块构建提供ES6模块. 一些工具会跟随包.json中的模块字段,如Rollup,Webpack,或Parcel.
-   通过ES6语法重构内部代码,不改变核心算法代码.
-   添加"uint8 clamped"(Uint8ClampedArray)支持.
-   其他改进.

你可以检查 [更改日志](https://github.com/grimmerk/numjs/blob/master/CHANGELOG.md)。 。 。 .

## 特征

**数字Js** 是一个 npm 软件包,用于使用 JavaScript 进行科学计算。 其中包括:

-   一个强大的 N-维阵列对象, `NdArray`
-   线性代数函数
-   快速傅里叶变换

除了其明显的科学用途外, **数字Js** 也可以用作通用数据的高效多维容器.

它在节点.js和浏览器中都有效.

**数字Js** 已根据该条例获得许可证 [麻省理工学院许可证](https://github.com/grimmerk/numjs/blob/master/LICENSE),使再利用几乎不受限制.

试试这个 [小说](https://jsfiddle.net/grimmerk/8jft09q3) 和图书馆一起玩.

## 安装

```sh
npm install @d4c/numjs 
# or 
yarn add @d4c/numjs
```

然后使用ES6导入:

```ts
import nj from "@d4c/numjs"; 
```

或共同JS要求:

```ts
// TypeScript users will not get typings when using require
const nj = require('@d4c/numjs').default; 
```

或者从CDN下载:

```html
<script type="module">
    import nj from 'https://cdn.jsdelivr.net/npm/@d4c/numjs/build/module/numjs.min.js';
    // optional: assign to global to let other code can use: globalThis.nj = nj;
</script>
```

如果使用 `ES6 import` 或者说 `CommonJS require` 在错误中恢复, 请尝试使用 `import nj from "@d4c/numjs/build/module/numjs.min.js` 在你的环境中.

## 基本情况

### 矩阵创建

```ts
> const a = nj.array([2,3,4]);
> a
array([ 2, 3, 4])
> const b = nj.array([[1,2,3], [4,5,6]]);
> b
array([[ 1, 2, 3],
       [ 4, 5, 6]])
```

**说明**: 默认数据容器是 JavaScript `Array` 对象。 如果需要,您也可以使用键入数组,例如 `Uint8Array`数字 :

```ts
> const a = nj.uint8([1,2,3]);
> a
array([ 1, 2, 3], dtype=uint8)
```

下面是创建相同的 `NdArray`。 。 。 .

```ts
const a = nj.array([1, 2, 3], "uint8");
const b = nj.array([1, 2, 3], Uint8Array);
const c = nj.array(new Uint8Array([1, 2, 3]));
const d = nj.arange(3,"uint8"); // results in array([ 0, 1, 2], dtype=uint8) 
// but we want [1,2,3], how?  
// we can manually create a scijs/ndarray object, then assign it as selection property 
d.selection = nj.ndarray(new Uint8Array([1, 2, 3]));
// d.selection.data is the stored raw Uint8Array([1, 2, 3])
```

**说明**:可能的类型有:int8,int8,int16,int16,int32,int32,floot32,floto64,int8 clamped和数组(默认)

要创建带有给定形状的阵列, 您可以使用 `zeros`, (中文(简体) ), `ones` 或者说 `random` 函数:

```ts
> nj.zeros([2,3]);
array([[ 0, 0, 0],
       [ 0, 0, 0]])
> nj.ones([2,3,4], 'int32')     // dtype can also be specified
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int32)

> nj.random([4,3])
array([[ 0.9182 , 0.85176, 0.22587],
       [ 0.50088, 0.74376, 0.84024],
       [ 0.74045, 0.23345, 0.20289],
       [ 0.00612, 0.37732, 0.06932]])
```

为了建立数字序列, **数字Js** 提供名为 `arange`数字 :

```ts
> nj.arange(4);
array([ 0, 1, 2, 3])

> nj.arange( 10, 30, 5 )
array([ 10, 15, 20, 25])

> nj.arange(1, 5, 'uint8');
array([ 1, 2, 3, 4], dtype=uint8)
```

#### 可选 NdArray 构造参数, 斜起并相冲

密码就像

```ts
// pass data, shape, stride, offset arguments.
// this will call nj.ndarray([2, 3, 4], [3], [1], 0) and assign it to NdArray's selection property
const a = new nj.NdArray([2, 3, 4], [3], [1], 0);
```

或者你想在原始的 scijs ndarray 对象上申请

```ts
// scijs ndarray object
const a = nj.ndarray([2, 3, 4], [3], [1], 0);
```

`NdArray and ndarray` 也被导出。 您还可以使用

```ts
import { NdArray, ndarray } from "@d4c/numjs"
// or CommonJS:
const NdArray = require('numjs').NdArray;
const ndarray = require('numjs').ndarray;
```

减少打字 "`nj.`" ..

### 关于阵列的更多信息

**数字Js**阵列类称为 `NdArray`被别名所取名 `array`。更为重要的属性 `NdArray` 对象为:

-   `NdArray#ndim`:阵列的轴数(dimensions).
-   `NdArray#shape`: 数组的尺寸。 这是一个表示每个维度中数组大小的整数列表. 对于有n行和m列的矩阵,形状为 \[n,m\]. 因此,形状的长度是维数,ndim.
-   `NdArray#size`: 数组的元素总数。 这相当于形状元素的产物.
-   `NdArray#dtype`: 描述数组中元素类型的字符串. `int32`, (中文(简体) ), `int16`,以及 `float64` 一些实例。 默认 Dtype 是 `array`。 。 。 .

一个 `NdArray` 总是可以转换成本地 JavaScript `Array` 使用 `NdArray#tolist()` 方法.

示例

```ts
> a = nj.arange(15).reshape(3, 5);
array([[  0,  1,  2,  3,  4],
       [  5,  6,  7,  8,  9],
       [ 10, 11, 12, 13, 14]])

> a.shape
[ 3, 5]
> a.ndim
2
> a.dtype
'array'
> a instanceof nj.NdArray
true
> a.tolist() instanceof Array
true
> a.get(1,1)
6
> a.set(0,0,1)
> a
array([[  1,  1,  2,  3,  4],
       [  5,  6,  7,  8,  9],
       [ 10, 11, 12, 13, 14]])

```

### 打印阵列

使用 `nj.array([2,3,4]` 作为例子。 在节点J, `console.log(nj.array([2,3,4])` 将打印美化的内容, `array([ 2, 3, 4])`。在浏览器中,或在节点.js中使用调试器,请使用 `console.log(nj.array([2,3,4].toString())` 以打印其被美化的内容. `toString()` 正在浏览器/ Node.js 中工作.

当你打印一个阵列的被美化的内容时, **数字Js** 以类似嵌入式列表的方式显示,但布局如下:

-   最后一个轴从左到右打印,
-   第二至倒数从上到下打印,
-   其余部分也从上而下地打印出,每个片段由一行空去相隔.

然后一维数组被打印为行,二维被打印为矩阵,三维被打印为矩阵列表.

```ts
> const a = nj.arange(6);                 // 1d array
> console.log(a);
array([ 0, 1, 2, 3, 4, 5])
>
> const b = nj.arange(12).reshape(4,3);   // 2d array
> console.log(b);
array([[  0,  1,  2],
       [  3,  4,  5],
       [  6,  7,  8],
       [  9, 10, 11]])
>
> const c = nj.arange(24).reshape(2,3,4); // 3d array
> console.log(c);
array([[[  0,  1,  2,  3],
        [  4,  5,  6,  7],
        [  8,  9, 10, 11]],
       [[ 12, 13, 14, 15],
        [ 16, 17, 18, 19],
        [ 20, 21, 22, 23]]])

```

如果一个阵列太大无法打印, **数字Js** 自动跳过数组的中心部分,只打印角:

```ts
> console.log(nj.arange(10000).reshape(100,100))
array([[    0,    1, ...,   98,   99],
       [  100,  101, ...,  198,  199],
        ...
       [ 9800, 9801, ..., 9898, 9899],
       [ 9900, 9901, ..., 9998, 9999]])
```

要自定义此行为, 您可以使用 `nj.config.printThreshold` (默认为 `7`:

```ts
> nj.config.printThreshold = 9;
> console.log(nj.arange(10000).reshape(100,100))
array([[    0,    1,    2,    3, ...,   96,   97,   98,   99],
       [  100,  101,  102,  103, ...,  196,  197,  198,  199],
       [  200,  201,  202,  203, ...,  296,  297,  298,  299],
       [  300,  301,  302,  303, ...,  396,  397,  398,  399],
        ...
       [ 9600, 9601, 9602, 9603, ..., 9696, 9697, 9698, 9699],
       [ 9700, 9701, 9702, 9703, ..., 9796, 9797, 9798, 9799],
       [ 9800, 9801, 9802, 9803, ..., 9896, 9897, 9898, 9899],
       [ 9900, 9901, 9902, 9903, ..., 9996, 9997, 9998, 9999]])

```

### 索引编制

单一元素索引用途 `get` 财务报告和审定财务报表 `set` 方法。 。 。 它基于0,并接受从数组末尾索引的负指数:

```ts
> const a = nj.array([0,1,2]);
> a.get(1)
1
>
> a.get(-1)
2
>
> const b = nj.arange(3*3).reshape(3,3);
> b
array([[  0,  1,  2],
       [  3,  4,  5],
       [  6,  7,  8])
>
> b.get(1, 1);
4
>
> b.get(-1, -1);
8
> b.set(0,0,1);
> b
array([[ 1, 1, 2],
       [ 3, 4, 5],
       [ 6, 7, 8]])
```

### 切开和切开

可以切片并出步数组来取出同个维数但大小与原相异的数组. 切片和切片在NumPy的操作方式完全相同:

```ts
> const a = nj.arange(5);
> a
array([  0,  1,  2,  3,  4])
>
> a.slice(1) // skip the first item, same as a[1:]
array([ 1, 2, 3, 4])
>
> a.slice(-3) // takes the last 3 items, same as a[-3:]
array([ 2, 3, 4])
>
> a.slice([4]) // takes the first 4 items, same as a[:4]
array([ 0, 1, 2, 3])
>
> a.slice([-2]) // skip the last 2 items, same as a[:-2]
array([ 0, 1, 2])
>
> a.slice([1,4]) // same as a[1:4]
array([ 1, 2, 3])
>
> a.slice([1,4,-1]) // same as a[1:4:-1]
array([ 3, 2, 1])
>
> a.slice([null,null,-1]) // same as a[::-1]
array([ 4, 3, 2, 1, 0])
>
> const b = nj.arange(5*5).reshape(5,5);
> b
array([[  0,  1,  2,  3,  4],
       [  5,  6,  7,  8,  9],
       [ 10, 11, 12, 13, 14],
       [ 15, 16, 17, 18, 19],
       [ 20, 21, 22, 23, 24]])
>
> b.slice(1,2) //  skip the first row and the 2 first  columns, same as b[1:,2:]
array([[  7,  8,  9],
       [ 12, 13, 14],
       [ 17, 18, 19],
       [ 22, 23, 24]])
>
> b.slice(null, [null, null, -1]) // reverse rows, same as b[:, ::-1]
array([[  4,  3,  2,  1,  0],
       [  9,  8,  7,  6,  5],
       [ 14, 13, 12, 11, 10],
       [ 19, 18, 17, 16, 15],
       [ 24, 23, 22, 21, 20]])
```

注意切片不复制内部数组数据,它会产生原始数据的新视图.

### 基本业务

算术运算符,例如 `*` (单位:千美元)`multiply`, (中文(简体) ), `+` (单位:千美元)`add`, (中文(简体) ), `-` (单位:千美元)`subtract`, (中文(简体) ), `/` (单位:千美元)`divide`, (中文(简体) ), `**` (单位:千美元)`pow`, (中文(简体) ), `=` (单位:千美元)`assign`)应用elemen-twise. 创建一个新的数组并填充结果 :

```ts
> zeros = nj.zeros([3,4]);
array([[ 0, 0, 0, 0],
       [ 0, 0, 0, 0],
       [ 0, 0, 0, 0]])
>
> ones = nj.ones([3,4]);
array([[ 1, 1, 1, 1],
       [ 1, 1, 1, 1],
       [ 1, 1, 1, 1]])
>
> ones.add(ones)
array([[ 2, 2, 2, 2],
       [ 2, 2, 2, 2],
       [ 2, 2, 2, 2]])
>
> ones.subtract(ones)
array([[ 0, 0, 0, 0],
       [ 0, 0, 0, 0],
       [ 0, 0, 0, 0]])
>
> zeros.pow(zeros)
array([[ 1, 1, 1, 1],
       [ 1, 1, 1, 1],
       [ 1, 1, 1, 1]])
>
```

要修改已有的数组,而不是创建新的数组,您可以设置 `copy` 参数改为 `false`数字 :

```ts
> ones = nj.ones([3,4]);
array([[ 1, 1, 1, 1],
       [ 1, 1, 1, 1],
       [ 1, 1, 1, 1]])
>
> ones.add(ones, false)
array([[ 2, 2, 2, 2],
       [ 2, 2, 2, 2],
       [ 2, 2, 2, 2]])
>
> ones
array([[ 2, 2, 2, 2],
       [ 2, 2, 2, 2],
       [ 2, 2, 2, 2]])
>
> zeros = nj.zeros([3,4])
> zeros.slice([1,-1],[1,-1]).assign(1, false);
> zeros
array([[ 0, 0, 0, 0],
       [ 0, 1, 1, 0],
       [ 0, 0, 0, 0]])
```

**说明**: 可供 `add`, (中文(简体) ), `subtract`, (中文(简体) ), `multiply`, (中文(简体) ), `divide`, (中文(简体) ), `assign` 财务报告和审定财务报表 `pow` 方法。 。 .

矩阵产品可以使用 `dot` 函数 :

```ts
> a = nj.arange(12).reshape(3,4);
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
>
> nj.dot(a.T, a)
array([[  80,  92, 104, 116],
       [  92, 107, 122, 137],
       [ 104, 122, 140, 158],
       [ 116, 137, 158, 179]])
>
> nj.dot(a, a.T)
array([[  14,  38,  62],
       [  38, 126, 214],
       [  62, 214, 366]])
```

许多非活性操作,如计算数组中所有元素的总和,都作为方法执行 `NdArray` 类 :

```ts
> a = nj.random([2,3])
array([[0.62755, 0.8278,0.21384],
       [ 0.7029,0.27584,0.46472]])
> a.sum()
3.1126488673035055
>
> a.min()
0.2138431086204946
>
> a.max()
0.8278025290928781
>
> a.mean()
0.5187748112172509
>
> a.std()
0.22216977543691244
```

### 通用函数

**数字Js** 提供熟悉的数学函数,例如 `sin`, (中文(简体) ), `cos`,以及 `exp`。这些函数在一个阵列上按元素运行,生成 `NdArray` 作为输出 :

```ts
> a = nj.array([-1, 0, 1])
array([-1, 0, 1])
>
> nj.negative(a)
array([ 1, 0,-1])
>
> nj.abs(a)
array([ 1, 0, 1])
>
> nj.exp(a)
array([ 0.36788,       1, 2.71828])
>
> nj.tanh(a)
array([-0.76159,       0, 0.76159])
>
> nj.softmax(a)
array([ 0.09003, 0.24473, 0.66524])
>
> nj.sigmoid(a)
array([ 0.26894,     0.5, 0.73106])
>
> nj.exp(a)
array([ 0.36788,       1, 2.71828])
>
> nj.log(nj.exp(a))
array([-1, 0, 1])
>
> nj.sqrt(nj.abs(a))
array([ 1, 0, 1])
>
> nj.sin(nj.arcsin(a))
array([-1, 0, 1])
>
> nj.cos(nj.arccos(a))
array([-1, 0, 1])
>
> nj.tan(nj.arctan(a))
array([-1, 0, 1])
```

### 形状操纵

数组的形状由每个轴的元素数量决定:

```ts
> a = nj.array([[  0,  1,  2,  3], [  4,  5,  6,  7], [  8,  9, 10, 11]]);
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])

> a.shape
[ 3, 4 ]
```

数组的外形可以用曲折命令来改变 :

```ts
> a.flatten();
array([  0,  1,  2, ...,  9, 10, 11])
>
> a.T                   // equivalent to a.transpose(1,0)
array([[  0,  4,  8],
       [  1,  5,  9],
       [  2,  6, 10],
       [  3,  7, 11]])
>
> a.reshape(4,3)
array([[  0,  1,  2],
       [  3,  4,  5],
       [  6,  7,  8],
       [  9, 10, 11]])
>
```

自兹 `a` 我们也许想要它的对角:

```ts
> nj.diag(a)
array([  0,  5, 10])
>
```

### 身份矩阵

身份阵列是一个正方形阵列,主要对角有:

```ts
> nj.identity(3)
array([[ 1, 0, 0],
       [ 0, 1, 0],
       [ 0, 0, 1]])
```

### 连接不同的数组

多个数组可使用 `concatenate` 函数 :

```ts
> a = nj.arange(12).reshape(3,4)
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
>
> b = nj.arange(3)
array([ 0, 1, 2])
>
> nj.concatenate(a,b.reshape(3,1))
array([[  0,  1,  2,  3,  0],
       [  4,  5,  6,  7,  1],
       [  8,  9, 10, 11,  2]])
```

**页:1**数字 :

-   数组必须具有相同的形状, 除了最后一个维
-   数组沿后一轴排列

仍有可能使用转接法将其他维相连接:

```ts
> a = nj.arange(12).reshape(3,4)
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
>
> b = nj.arange(4)
array([ 0, 1, 2, 3])
>
> nj.concatenate(a.T,b.reshape(4,1)).T
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11],
       [  0,  1,  2,  3]])
```

### 堆叠多个数组

```ts
> a = nj.array([1, 2, 3])
> b = nj.array([2, 3, 4])

> nj.stack([a, b])
array([[1, 2, 3],
       [2, 3, 4]])
> nj.stack([a, b], -1)
array([[1, 2],
       [2, 3],
       [3, 4]])
```

**页:1**数字 :

-   阵列必须具有相同的形状
-   选择可选轴参数,该参数可以是负数

### 深层复制

这个 `clone` 方法使数组及其数据的完整副本.

```ts
> a = nj.arange(12).reshape(3,4)
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
>
> b = a.clone()
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
>
> a === b
false
>
> a.set(0,0,1)
> a
array([[  1,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
> b
array([[  0,  1,  2,  3],
       [  4,  5,  6,  7],
       [  8,  9, 10, 11]])
```

### 快速傅里叶变形 (FFT)

`fft` 财务报告和审定财务报表 `ifft` 函数可用于计算N维离散的傅里叶变形及其反相.

示例

```ts
> RI = nj.concatenate(nj.ones([10,1]), nj.zeros([10,1]))
array([[ 1, 0],
       [ 1, 0],
       [ 1, 0],
        ...
       [ 1, 0],
       [ 1, 0],
       [ 1, 0]])
>
> fft = nj.fft(RI)
array([[ 10,  0],
       [  0,  0],
       [  0,  0],
        ...
       [  0,  0],
       [  0,  0],
       [  0,  0]])
>
> nj.ifft(fft)
array([[ 1, 0],
       [ 1, 0],
       [ 1, 0],
        ...
       [ 1, 0],
       [ 1, 0],
       [ 1, 0]])
```

**说明**: 两者 `fft` 财务报告和审定财务报表 `ifft` 期望数组的最后一个维度包含 2 个值: 真实值和假想值

### 进取

`convolve` 函数计算两个多维数组的离散线性演化.

**说明**: 演化产物只用于信号完全重叠的点. 信号边界外的值没有效果. 这种行为也被称为"有效"模式.

示例

```ts
> x = nj.array([0,0,1,2,1,0,0])
array([ 0, 0, 1, 2, 1, 0, 0])
>
> nj.convolve(x, [-1,0,1])
array([-1,-2, 0, 2, 1])
>
> const a = nj.arange(25).reshape(5,5)
> a
array([[  0,  1,  2,  3,  4],
       [  5,  6,  7,  8,  9],
       [ 10, 11, 12, 13, 14],
       [ 15, 16, 17, 18, 19],
       [ 20, 21, 22, 23, 24]])
> nj.convolve(a, [[ 1, 2, 1], [ 0, 0, 0], [-1,-2,-1]])
array([[ 40, 40, 40],
       [ 40, 40, 40],
       [ 40, 40, 40]])
> nj.convolve(nj.convolve(a, [[1, 2, 1]]), [[1],[0],[-1]])
array([[ 40, 40, 40],
       [ 40, 40, 40],
       [ 40, 40, 40]])
```

**说明**数字 : `convolve` 使用Fast Fourier Transform (FFT)来加速对大型阵列的计算.

### 其他倾斜

`rot90`

```ts
> m = nj.array([[1,2],[3,4]], 'int8')
> m
array([[1, 2],
       [3, 4]])
> nj.rot90(m)
array([[2, 4],
       [1, 3]])
> nj.rot90(m, 2)
array([[4, 3],
       [2, 1]])
> m = nj.arange(8).reshape([2,2,2])
> nj.rot90(m, 1, [1,2])
array([[[1, 3],
        [0, 2]],
      [[5, 7],
       [4, 6]]])
```

`mod` (自v.16.0起)

```ts
> nj.mod(nj.arange(7), 5)
> m
array([0, 1, 2, 3, 4, 0, 1])
```

## 贡献者

此工程是 TypeScript 移植 [数字](https://github.com/nicolaspanel/numjs) 以 [@nicolaspanel (英语)](https://github.com/nicolaspanel)。 。 。 .

感谢下列人士的贡献:

-   [@pppp606 (英语)](https://github.com/pppp606) ——支持 `multiply` 财务报告和审定财务报表 `divide` (单位:千美元)[#14号](https://github.com/grimmerk/numjs/pull/14)(中文(简体) )

## 文档

-   [@d4c/numjs (韩语)](https://grimmerk.github.io/numjs/)
    -   [数字模块 (nj) doc](https://grimmerk.github.io/numjs/modules/)
    -   [NdArray 文档](https://grimmerk.github.io/numjs/classes/ndarray.NdArray.html)

## 常见问题

### @d4c/numjs 是什么？

像 NumPy, 在 TypeScript 和 JavaScript 中

### 如何安装 @d4c/numjs？

在项目目录运行 npm install @d4c/numjs，或使用 pnpm add / yarn add / bun add。

### @d4c/numjs 支持 TypeScript 吗？

支持。包内自带 TypeScript 类型声明（package\.json 声明了 types 入口），安装后即可获得类型提示，无需再安装 @types 包。

### @d4c/numjs 支持 ESM 还是 CommonJS？

同时提供 ES Module 与 CommonJS 入口，import 和 require\(\) 都可以使用，打包工具会自动选择合适的版本。

### @d4c/numjs 需要什么版本的 Node\.js？

package\.json 的 engines 字段要求 Node\.js \>=20。版本不符时 npm 默认只给出警告，开启 engine-strict 后会拒绝安装。

### @d4c/numjs 可以商用吗？

@d4c/numjs 使用 MIT 许可。宽松许可：允许商业使用、修改和再分发，通常只需在分发时保留原版权与许可声明。以上为概括，不构成法律意见，请以许可原文为准。

### @d4c/numjs 的下载量有多少？

根据 npm 官方下载统计，@d4c/numjs 在 2026/10/11 – 2026/11/09 这 30 天内被下载 2,492 次，日均约 83 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### @d4c/numjs 还在维护吗？

最新版本 0\.17\.35 发布于 2026/03/07（8 个月前）；至今共发布 36 个版本，其中过去 12 个月发布了 1 个；首次发布于 2021/11/08。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。