Arraymancer - 一个N维张量（ndarray）库。

Arraymancer是用Nim编写的张量（N维数组）项目。其主要目标是提供一个快速且易用的CPU、Cuda和OpenCL ndarray库，以此为基础构建科学计算生态系统。 该库受到NumPy和PyTorch的启发，适用于以下场景：

• 用于数值计算的N维数组（张量）
• 机器学习算法（如Scikit-learn中的最小二乘法求解器、PCA与降维、分类器、回归器和聚类算法、交叉验证等）
• 深度学习

ndarray组件可以独立于机器学习和深度学习部分使用。它还支持OpenMP、Cuda或OpenCL后端。

注意：虽然Nim是编译型语言，目前尚不提供像Jupyter那样的交互式REPL，但由于其极快的编译速度，相比C++能够实现更快的原型开发。在我双核MacBook上，Arraymancer大约5秒即可完成编译。

支持的编译标志说明：

• -d:release：Nim发布模式（无堆栈跟踪和调试信息）
• -d:danger：禁用运行时检查，如数组越界检查
• -d:blas=blaslibname：自定义Arraymancer使用的BLAS库。默认情况下（即未设置此选项时），Arraymancer会尝试在系统路径中自动查找BLAS库（例如blas.so/blas.dll或libopenblas.dll）。只有在需要使用特定BLAS库时才应设置此选项。更多信息请参见nimblas
• -d:lapack=lapacklibname：自定义Arraymancer使用的LAPACK库。默认情况下（即未设置此选项时），Arraymancer会尝试在系统路径中自动查找LAPACK库（例如lapack.so/lapack.dll或libopenblas.dll）。只有在需要使用特定LAPACK库时才应设置此选项。更多信息请参见nimlapack
• -d:openmp：多线程编译
• -d:mkl：已弃用的标志，强制使用MKL。同时隐含-d:openmp。建议改用-d:blas=mkl -d:lapack=mkl，但仅当您希望强制Arraymancer使用MKL而非自动查找可用的BLAS/LAPACK库时才适用。
• -d:openblas：已弃用的标志，强制使用OpenBLAS。建议改用-d:blas=openblas -d:lapack=openblas，但仅当您希望强制Arraymancer使用OpenBLAS而非自动查找可用的BLAS/LAPACK库时才适用。
• -d:cuda：启用Cuda支持进行编译
• -d:cudnn：启用CuDNN支持，同时隐含-d:cuda
• -d:avx512：通过向gcc/clang传递-mavx512dq标志来启用AVX512支持。若不使用此标志，即使CPU支持AVX512，生成的二进制文件也不会利用该指令集。然而，启用此标志会使二进制文件无法在不支持AVX512的CPU上运行。相关讨论请参见#505（来自v0.7.9版本）。
• 安装完成后，您可能需要调整nim.cfg中的库路径，以便进行OpenBLAS、MKL和Cuda编译。 当前的默认设置在Mac和Linux上应该可以正常工作；而在Windows上，则需下载libopenblas.dll或其他BLAS/LAPACK DLL（详见“安装”章节），并将其复制到系统路径中的某个文件夹或编译输出目录中。

给我看看代码吧

Arraymancer教程可在这里找到。

以下是Arraymancer语法的一个预览。

张量创建与切片

import math, arraymancer

const
    x = @[1, 2, 3, 4, 5]
    y = @[1, 2, 3, 4, 5]

var
    vandermonde = newSeq[seq[int]]()
    row: seq[int]

for i, xx in x:
    row = newSeq[int]()
    vandermonde.add(row)
    for j, yy in y:
        vandermonde[i].add(xx^yy)

let foo = vandermonde.toTensor()

echo foo

# Tensor[system.int] of shape "[5, 5]" on backend "Cpu"
# |1          1       1       1       1|
# |2          4       8      16      32|
# |3          9      27      81     243|
# |4         16      64     256    1024|
# |5         25     125     625    3125|

echo foo[1..2, 3..4] # slice

# Tensor[system.int] of shape "[2, 2]" on backend "Cpu"
# |16      32|
# |81     243|

echo foo[_|-1, _] # reverse the order of the rows

# Tensor[int] of shape "[5, 5]" on backend "Cpu"
# |5      25      125     625     3125|
# |4      16       64     256     1024|
# |3       9       27      81      243|
# |2       4        8      16       32|
# |1       1        1       1        1|

重塑与拼接

import arraymancer, sequtils

let a = toSeq(1..4).toTensor.reshape(2,2)

let b = toSeq(5..8).toTensor.reshape(2,2)

let c = toSeq(11..16).toTensor
let c0 = c.reshape(3,2)
let c1 = c.reshape(2,3)

echo concat(a,b,c0, axis = 0)
# Tensor[system.int] of shape "[7, 2]" on backend "Cpu"
# |1      2|
# |3      4|
# |5      6|
# |7      8|
# |11    12|
# |13    14|
# |15    16|

echo concat(a,b,c1, axis = 1)
# Tensor[system.int] of shape "[2, 7]" on backend "Cpu"
# |1      2     5     6    11    12    13|
# |3      4     7     8    14    15    16|

广播

图片来自Scipy

import arraymancer

let j = [0, 10, 20, 30].toTensor.reshape(4,1)
let k = [0, 1, 2].toTensor.reshape(1,3)

echo j +. k
# Tensor[system.int] of shape "[4, 3]" on backend "Cpu"
# |0      1     2|
# |10    11    12|
# |20    21    22|
# |30    31    32|

一个简单的两层神经网络

摘自示例3。

import arraymancer, strformat

discard """
一个具有单个隐藏层的全连接ReLU网络，通过最小化欧几里得距离的平方来训练预测y从x。
"""

# ##################################################################
# 环境变量

# N是批量大小；D_in是输入维度；
# H是隐藏维度；D_out是输出维度。
let (N, D_in, H, D_out) = (64, 1000, 100, 10)

# 创建将保存计算图的自动微分上下文
let ctx = newContext Tensor[float32]

# 创建随机张量作为输入和输出，并将其包装为Variable。
let
  x = ctx.variable(randomTensor[float32](N, D_in, 1'f32))
  y = randomTensor[float32](N, D_out, 1'f32)

# ##################################################################

# 定义模型

网络 TwoLayersNet:
  层:
    fc1: 线性(D_in, H)
    fc2: 线性(H, D_out)
  前向传播 x:
    x.fc1.relu.fc2

让
  模型 = 上下文.初始化(TwoLayersNet)
  优化器 = 模型.优化器(SGD, 学习率 = 1e-4'f32)

# ##################################################################
# 训练

对于 t 在 0 ..< 500:
  让
    y_pred = 模型.前向传播(x)
    损失 = y_pred.mse_loss(y)

  打印 &"第 {t} 轮：损失 {loss.value[0]}"

  损失.反向传播()
  优化器.更新()

预告 使用 Arraymancer 的循环神经网络生成的文本

来自 示例 6。

在我的笔记本电脑 CPU 上训练了 45 分钟，生成了 4000 个字符

威瑟！
仆人封印着，只做出些卑鄙的猜测，
他们不过是那些一直对我不忠的人；
你的戏码让王后的妻子看到了错误的部分
带着一个奇怪、可怜又可怕的冷酷的孩子
罪犯们会如何评价你的角色呢？我，王子！
现在不是没有牙齿的时候：
你对此只是肮脏而已。
我和伙伴们打破了我的复仇，所以，以及他的历史
就像你们这些领主一样，或者说是港口的真正盐分。

罗密欧：
你已经发誓要保护自己，并且正在谈论他们；她是不是被你的胆汁谋杀了？

# [...] 查看示例 6 获取完整的文本生成样本

目录

• Arraymancer - 一种 n 维张量（ndarray）库。
  • 给我看看代码
    • 张量的创建和切片
    • 重塑和拼接
    • 广播
    • 一个简单的两层神经网络
    • 预告 使用 Arraymancer 的循环神经网络生成的文本
  • 目录
  • 安装
  • 完整文档
  • 特性
    • Arraymancer 作为深度学习库
      • 用全连接层（也称为密集层、仿射层或线性层）实现 Fizzbuzz
      • 用卷积进行手写数字识别
      • 用堆叠的循环神经网络进行序列分类
    • CPU、CUDA 和 OpenCL 上的张量
  • Arraymancer v0.5.1 - 2019 年 7 月的新功能
  • 选择 Arraymancer 的 4 个理由
    • Python 社区正努力使 NumPy 跟上时代
    • 研究人员的工作流程是在与低效作斗争
    • 几乎无需依赖即可分发
    • 弥合深度学习研究与生产之间的鸿沟
    • 那么为什么选择 Arraymancer？
  • 未来的抱负

安装

Nim 在一些 Linux 发行版的软件仓库中以及 macOS 的 Homebrew 中都可以找到。

不过，我建议通过 choosenim 将 Nim 安装到您的用户目录中。一旦使用 choosenim 安装了 Nim，您就可以运行 nimble install arraymancer，这将下载最新的 Arraymancer 版本及其所有依赖项。

如果您想安装 Arraymancer 的开发版本，可以使用 nimble install arraymancer@#head。

Arraymancer 需要 BLAS 和 LAPACK 库。

• 在 Windows 上，您可以从 OpenBLAS 网站的二进制包部分获取 OpenBLAS 库，它将 BLAS 和 LAPACK 合并为一个 DLL 文件（libopenblas.dll）。或者，您也可以从 LAPACK for Windows 网站单独下载 BLAS 和 LAPACK 库。然后，您需要将这些 DLL 文件复制或解压到您的系统路径中的某个文件夹，或者放到包含编译目标的文件夹中。
• 在 macOS 上，Apple Accelerate Framework 已经包含在所有 macOS 版本中，提供了这些库。
• 在 Linux 上，您可以使用包管理器下载 libopenblas 和 liblapack。

Windows 用户可能需要从 openblas 的二进制发布部分下载 libopenblas.dll，将其解压到编译

完整文档

详细的 API 文档可在 Arraymancer 官方 文档 中找到。注意：此文档仅针对 0.X 版本生成。请查看 示例文件夹 以了解最新的开发进展。

特性

目前，Arraymancer 主要处于多维数组阶段，具体来说，Arraymancer 提供以下功能：

• 基本数学运算推广到张量（sin、cos 等）
• 矩阵代数原语：矩阵-矩阵、矩阵-向量乘法
• 简单高效的切片操作，包括使用范围和步长
• 无需担心“矢量化”操作
• 支持广播。与 NumPy 不同，它是显式的，您只需使用 +. 而不是 +
• 丰富的重塑操作：拼接、重塑、拆分、分块、排列、转置
• 支持最多 6 维的张量。例如，4 部 3D RGB 微电影，每部 10 秒，就是 6 维： [4, 10, 3, 64, 1920, 1080] 对应 [影片数量、时间、颜色、深度、高度、宽度]
• 可以读取和写入 .csv、Numpy (.npy) 和 HDF5 文件
• OpenCL 和 CUDA 加速的张量（目前功能不如 CPU 张量丰富）
• 协方差矩阵
• 特征值和特征向量分解
• 最小二乘法求解器
• K-means 和 PCA（主成分分析）

Arraymancer 作为深度学习库

深度学习功能目前仍可探索，但被认为不稳定，因为我还在完善其最终接口。

提醒：最终接口仍在 开发中。

您还可以观看以下动画版 神经网络演示，该演示展示了通过 nim-plotly 进行的实时训练。

Fizzbuzz 用全连接层（也称为密集层、仿射层或线性层）

神经网络定义摘自 示例 4。

导入 arraymancer

常量
  数字位数 = 10
  隐藏层节点数 = 100

网络 FizzBuzzNet:
  层:
    隐藏层: 线性(数字位数, 隐藏层节点数)
    输出层: 线性(隐藏层节点数, 4)
  前向传播 x:
    x.隐藏层.relu.输出层

让
  上下文 = 新建上下文 Tensor[float32]
  模型 = 上下文.初始化(FizzBuzzNet)
  优化器 = 模型.优化器(SGD, 0.05'f32)
# ....
打印答案
# @["1", "2", "fizz", "4", "buzz", "6", "7", "8", "fizz", "10",

#   "11", "12", "13", "14", "15", "16", "17", "fizz", "19", "buzz",
#   "fizz", "22", "23", "24", "buzz", "26", "fizz", "28", "29", "30",
#   "31", "32", "fizz", "34", "buzz", "36", "37", "38", "39", "40",
#   "41", "fizz", "43", "44", "fizzbuzz", "46", "47", "fizz", "49", "50",
#   "fizz", "52","53", "54", "buzz", "56", "fizz", "58", "59", "fizzbuzz",
#   "61", "62", "63", "64", "buzz", "fizz", "67", "68", "fizz", "buzz",
#   "71", "fizz", "73", "74", "75", "76", "77","fizz", "79", "buzz",
#   "fizz", "82", "83", "fizz", "buzz", "86", "fizz", "88", "89", "90",
#   "91", "92", "fizz", "94", "buzz", "fizz", "97", "98", "fizz", "buzz"]

使用卷积的手写数字识别

神经网络定义摘自示例 2。

import arraymancer

network DemoNet:
  layers:
    cv1:        Conv2D(@[1, 28, 28], out_channels = 20, kernel_size = (5, 5))
    mp1:        Maxpool2D(cv1.out_shape, kernel_size = (2,2), padding = (0,0), stride = (2,2))
    cv2:        Conv2D(mp1.out_shape, out_channels = 50, kernel_size = (5, 5))
    mp2:        MaxPool2D(cv2.out_shape, kernel_size = (2,2), padding = (0,0), stride = (2,2))
    fl:         Flatten(mp2.out_shape)
    hidden:     Linear(fl.out_shape[0], 500)
    classifier: Linear(500, 10)
  forward x:
    x.cv1.relu.mp1.cv2.relu.mp2.fl.hidden.relu.classifier

let
  ctx = newContext Tensor[float32] # 自动求导/神经网络图
  model = ctx.init(DemoNet)
  optim = model.optimizer(SGD, learning_rate = 0.01'f32)

# ...
# 在笔记本电脑的 CPU 上，几分钟内准确率就能超过 90%

使用堆叠循环神经网络进行序列分类

神经网络定义摘自示例 5。

import arraymancer

const
  HiddenSize = 256
  Layers = 4
  BatchSize = 512


network TheGreatSequencer:
  layers:
    gru1: GRULayer(1, HiddenSize, 4) # (输入特征数, 隐藏层大小, 堆叠层数)
    fc1: Linear(HiddenSize, 32)                  # 每个 GRU 层一个分类器
    fc2: Linear(HiddenSize, 32)
    fc3: Linear(HiddenSize, 32)
    fc4: Linear(HiddenSize, 32)
    classifier: Linear(32 * 4, 3)                # 将四个分类器的输出堆叠后送入一个学习型分类器
  forward x, hidden0:
    let
      (output, hiddenN) = gru1(x, hidden0)
      clf1 = hiddenN[0, _, _].squeeze(0).fc1.relu
      clf2 = hiddenN[1, _, _].squeeze(0).fc2.relu
      clf3 = hiddenN[2, _, _].squeeze(0).fc3.relu
      clf4 = hiddenN[3, _, _].squeeze(0).fc4.relu

    # 将所有结果拼接起来
    # 由于目前尚未实现拼接操作的反向传播，我们通过堆叠的方式“作弊”
    # 然后再展平
    result = stack(clf1, clf2, clf3, clf4, axis = 2)
    result = classifier(result.flatten)

# 初始化模型
let
  ctx = newContext Tensor[float32]
  model = ctx.init(TheGreatSequencer)
  optim = model.optimizer(SGD, 0.01'f32)

# ...
let exam = ctx.variable([
    [float32 0.10, 0.20, 0.30], # 递增
    [float32 0.10, 0.90, 0.95], # 递增
    [float32 0.45, 0.50, 0.55], # 递增
    [float32 0.10, 0.30, 0.20], # 非单调
    [float32 0.20, 0.10, 0.30], # 非单调
    [float32 0.98, 0.97, 0.96], # 递减
    [float32 0.12, 0.05, 0.01], # 递减
    [float32 0.95, 0.05, 0.07]  # 非单调
  ])
# ...
echo answer.unsqueeze(1)
# Tensor[ex05_sequence_classification_GRU.SeqKind] of shape [8, 1] of type "SeqKind" on backend "Cpu"
# 	  Increasing|
# 	  Increasing|
# 	  Increasing|
# 	  NonMonotonic|
# 	  NonMonotonic|
# 	  Increasing| <----- 错误！
# 	  Decreasing|
# 	  NonMonotonic|

组合模型

网络模型也可以作为其他网络定义中的层。 上面的手写数字识别模型也可以这样写：

import arraymancer

network SomeConvNet:
  layers h, w:
    cv1:        Conv2D(@[1, h, w], 20, (5, 5))
    mp1:        Maxpool2D(cv1.out_shape, (2,2), (0,0), (2,2))
    cv2:        Conv2D(mp1.out_shape, 50, (5, 5))
    mp2:        MaxPool2D(cv2.out_shape, (2,2), (0,0), (2,2))
    fl:         Flatten(mp2.out_shape)
  forward x:
    x.cv1.relu.mp1.cv2.relu.mp2.fl

# 这个模型可以这样初始化：let model = ctx.init(SomeConvNet, h = 28, w = 28)

# 函数 `out_shape` 和 `in_shape` 返回一个 `seq[int]` 是一种约定（但并非严格必要），
# 适用于具有明确输出和输入尺寸的层或模型。
proc out_shape*[T](self: SomeConvNet[T]): seq[int] =
  self.fl.out_shape
proc in_shape*[T](self: SomeConvNet[T]): seq[int] =
  self.cv1.in_shape

network DemoNet:
  layers:
    # 这里我们将之前定义的 SomeConvNet 用作一层
    cv:         SomeConvNet(28, 28)
    hidden:     Linear(cv.out_shape[0], 500)
    classifier: Linear(hidden.out_shape[0], 10)
  forward x:
    x.cv.hidden.relu.classifier

自定义层

也可以创建完全自定义的层。 相关文档可以在官方 API 文档中找到。

CPU、CUDA 和 OpenCL 上的张量

目前，Tensor、CudaTensor 和 CLTensor 尚未实现完全相同的功能。此外，CudaTensor 和 CLTensor 只能是 float32 或 float64 类型，而 CpuTensor 则可以是整数、字符串、布尔值或任何自定义对象。

以下是核心功能的对比表。

操作	Tensor	CudaTensor	ClTensor
访问张量属性	[x]	[x]	[x]
张量创建	[x]	通过转换 CPU 张量	通过转换 CPU 张量
访问或修改单个元素	[x]	[]	[]
遍历张量	[x]	[]	[]
张量切片	[x]	[x]	[x]
切片赋值 a[1,_] = 10	[x]	[]	[]
比较 ==	[x]	[]	[]
元素级基本运算	[x]	[x]	[x]
通用函数	[x]	[]	[]
自动广播操作	[x]	[x]	[x]
矩阵-矩阵和矩阵-向量乘法	[x]	[x]	[x]
显示张量	[x]	[x]	[x]
高阶函数（map、apply、reduce、fold）	[x]	仅限内部使用	仅限内部使用
转置	[x]	[x]	[]
转换为连续存储	[x]	[x]	[]
改变形状	[x]	[x]	[]
显式广播	[x]	[x]	[x]
维度置换	[x]	[]	[]
沿现有维度拼接张量	[x]	[]	[]
压缩单例维度	[x]	[x]	[]
切片 + 压缩	[x]	[]	[]

Arraymancer 的新特性

完整的变更日志可在 changelog.md 中查看。

为什么选择 Arraymancer 的四个理由

Python 社区难以使 NumPy 跟上时代步伐

• Numba JIT 编译器
• Dask 延迟并行计算图
• Cython 用于简化 Python 中的数值计算
• 由于 GIL 的存在，纯 Python 中无法实现共享内存并行化（OpenMP）
• 使用“向量化操作”（即避免在 Python 中使用 for 循环）

为什么不使用一种语言，将所有必要的组件整合在一起，构建出兼具 Python 易用性与高效性的科学计算库呢？

OpenMP 直接内置其中。

研究人员的工作流程往往与低效作斗争

在需要大量科学计算的研究领域中，研究人员通常会经历以下工作流程：Mathematica/Matlab/Python/R（原型开发）→ C/C++/Fortran（速度与内存优化）。

为什么不使用一种既像 Python 一样高效，又像 C 语言一样快速的语言呢？只需编写一次代码，便无需花费数月时间在更低层次上重复同样的工作。

几乎无需依赖即可分发

Arraymancer 的模型可以被打包成一个自包含的二进制文件，该文件仅依赖于 BLAS 库，如 OpenBLAS、MKL 或 Apple Accelerate（所有 Mac 和 iOS 设备上均已提供）。

这意味着用户无需安装庞大的库或语言生态系统即可使用 Arraymancer。这也使其天然适用于资源受限的设备，例如手机和 Raspberry Pi。

弥合深度学习研究与生产之间的鸿沟

当前的深度学习框架主要分为两类：

• 研究类：Theano、TensorFlow、Keras、Torch、PyTorch
• 生产类：Caffe、Darknet、（TensorFlow）

此外，除非使用 OpenCV，否则 Python 的预处理步骤通常需要自定义实现（例如手机上的文本/语音预处理）。

• 以可靠的方式管理和部署 Python（2.7、3.5、3.6）及其软件包版本，需要具备 DevOps 技能（virtualenv、Docker等）。
• Python 数据科学生态系统无法在嵌入式设备（如 Nvidia Tegra 或无人机）以及手机上运行，尤其是预处理相关的依赖项。
• TensorFlow 本应弥合研究与生产之间的差距，但其语法和易用性令人头疼。对于研究人员而言，仍然需要两次编码：“先用 Keras 做原型，等到需要底层操作时再转到 TensorFlow”。
• 已部署的模型是静态的，没有任何框架提供添加新观测值或训练样本的接口。如果希望将模型作为具有在线学习能力的 Web 服务使用，该怎么办？

相关 XKCD 漫画，2018 年 4 月 30 日

那么，为什么选择 Arraymancer？

上述种种痛点看似艰巨，然而得益于 Nim 语言，我们得以实现 Arraymancer：

• 速度媲美 C 语言
• 通过 Intel MKL/OpenBLAS 甚至 NNPACK 加速计算
• 支持 CUDA 和 CuDNN，并可通过元编程动态生成自定义 CUDA 内核
• 几乎无需依赖即可分发（仅需 BLAS 库）
• 类似 Python 的语法，支持自定义运算符 a * b 进行张量乘法，而非 a.dot(b)（NumPy/TensorFlow）或 a.mm(b)（Torch）
• 类似 NumPy 的切片操作，如 t[0..4, 2..10|2]
• 对于 Nim 尚未提供的功能，可以通过 Nim 与 C、C++、Objective-C 或 JavaScript 的绑定将其引入 Nim。Nim 还提供了非官方的 Python↔Nim 绑定。

未来的抱负

既然 apparently 要想成功就得有个愿景，那我就希望 Arraymancer 能成为：

• 深度学习视频处理的首选工具。比如：vid = load_video("./cats/youtube_cat_video.mkv")
• 支持 JavaScript、WebAssembly、Apple Metal、ARM 设备、AMD ROCm、OpenCL 等多种平台，你想得到的它都能支持。
• 成为一款《星际争霸 II》AI 机器人的基础框架。
• 专门面向加密货币挖矿用的 FPGA，因为它们把 GPU 的价格抬得太高了，让真正搞深度学习的研究者都买不起了。

Arraymancer 快速上手指南

Arraymancer 是一个基于 Nim 语言的高性能 N 维张量（ndarray）库，灵感来源于 Numpy 和 PyTorch。它支持 CPU、CUDA 和 OpenCL 后端，适用于科学计算、机器学习及深度学习任务。

环境准备

系统要求

• 操作系统：Windows, macOS, Linux
• 编译器：Nim (推荐最新稳定版)
• 硬件加速（可选）：
  • NVIDIA GPU (需安装 CUDA Toolkit)
  • 支持 AVX512 指令集的 CPU (如需极致性能)

前置依赖

Arraymancer 依赖线性代数库 BLAS 和 LAPACK。请根据操作系统预先安装：

• Windows:
  • 下载 OpenBLAS 二进制包。
  • 获取 libopenblas.dll，将其复制到系统 PATH 路径下或项目编译输出目录中。
• macOS:
  • 系统自带 Apple Accelerate Framework，无需额外安装。
• Linux:
  • 使用包管理器安装，例如 Ubuntu/Debian: sudo apt-get install libopenblas-dev liblapack-dev。

提示：国内用户安装 Nim 推荐使用 choosenim 工具，它支持自动选择国内镜像源加速下载。

安装步骤

1. 安装 Nim

推荐使用 choosenim 进行安装和管理（支持 Windows/macOS/Linux）：

# 下载安装 choosenim (Windows PowerShell)
curl https://nim-lang.org/choosenim/init_stable.sh -o init_stable.sh
sh init_stable.sh

# 或者直接在终端运行安装脚本
curl https://nim-lang.org/choosenim/init_stable.sh | sh

安装完成后，确保 nim 和 nimble 命令可用。

2. 安装 Arraymancer

使用 Nim 的包管理器 nimble 安装：

# 安装最新稳定版
nimble install arraymancer

# 或者安装开发最新版
nimble install arraymancer@#head

基本使用

以下示例展示如何创建张量、进行切片操作以及执行简单的广播运算。

1. 创建与切片 (Tensor Creation and Slicing)

创建一个范德蒙德矩阵并进行切片：

import math, arraymancer

const
    x = @[1, 2, 3, 4, 5]
    y = @[1, 2, 3, 4, 5]

var
    vandermonde = newSeq[seq[int]]()
    row: seq[int]

for i, xx in x:
    row = newSeq[int]()
    vandermonde.add(row)
    for j, yy in y:
        vandermonde[i].add(xx^yy)

let foo = vandermonde.toTensor()

echo foo
# 输出形状为 [5, 5] 的张量

echo foo[1..2, 3..4] # 切片操作
# 输出形状为 [2, 2] 的子张量

echo foo[_|-1, _] # 反转行顺序

2. 广播机制 (Broadcasting)

演示类似 Numpy 的广播加法：

import arraymancer

let j = [0, 10, 20, 30].toTensor.reshape(4,1)
let k = [0, 1, 2].toTensor.reshape(1,3)

echo j +. k
# 输出形状为 [4, 3] 的张量，实现行列自动广播相加
# |0      1     2|
# |10    11    12|
# |20    21    22|
# |30    31    32|

3. 编译与运行

将代码保存为 main.nim，使用以下命令编译并运行（开启释放模式以获得最佳性能）：

# 基础编译
nim c -r main.nim

# 开启优化发布模式 (推荐)
nim c -d:release -r main.nim

# 若需启用 CUDA 支持
nim c -d:cuda -d:release -r main.nim

注意：默认情况下 Arraymancer 会自动查找系统中的 BLAS/LAPACK 库。如果找不到，可通过 -d:blas=openblas 等标志指定，或确保动态链接库在正确路径下。