如何从教堂的档案中读取矩阵

Question

这一次我有一个矩阵--在一个叫做"matrix.csv“的文件中，我想把它读进去。我可以有两种口味，浓密和稀疏。

稠密

matrix.csv

3.0, 0.8, 1.1, 0.0, 2.0
0.8, 3.0, 1.3, 1.0, 0.0
1.1, 1.3, 4.0, 0.5, 1.7
0.0, 1.0, 0.5, 3.0, 1.5
2.0, 0.0, 1.7, 1.5, 3.0

稀疏

matrix.csv
1,1,3.0
1,2,0,8
1,3,1.1
// 1,4 is missing
1,5,2.0
...
5,5,3.0

假设文件相当大。在这两种情况下，我都希望将这些信息读入具有适当维度的矩阵中。在密集的情况下，我可能不需要提供元数据。在第二个阶段，我想我应该提供矩阵的“框架”，比如

matrix.csv
nrows:5
ncols:5

但我不知道标准的模式。

==更新==

这有点难找到，但斑马鱼可以将您的一天从“崩溃服务器”改为“在11秒内完成”。感谢布拉德·克雷(不是他的真名)指出这一点！

Answer 1

前言

由于教堂矩阵被表示为数组，这个问题相当于：

“如何从教堂堂的文件中读取数组”。

理想情况下，csv模块或专门的IO-格式化程序(类似于JSON格式化程序)将更优雅地处理csv I/O，但这个答案反映了教堂1.16预发布时可用的数组I/O选项。

密集阵列I/O

密集数组是很简单的情况，因为DefaultRectangular数组( Chapel数组的默认type )附带了.readWriteThis(f)方法。此方法允许使用内置的write()和read()方法读写数组，如下所示：

var A: [1..5, 1..5] real;

// Give this array some values
[(i,j) in A.domain] A[i,j] = i + 10*j;

var writer = open('dense.txt', iomode.cw).writer();

writer.write(A);

writer.close();

var B: [1..5, 1..5] real;
var reader = open('dense.txt', iomode.r).reader();
reader.read(B);
reader.close();

assert(A == B);

dense.txt看起来如下所示：

11.0 21.0 31.0 41.0 51.0
12.0 22.0 32.0 42.0 52.0
13.0 23.0 33.0 43.0 53.0
14.0 24.0 34.0 44.0 54.0
15.0 25.0 35.0 45.0 55.0

但是，这假设您预先知道数组形状。我们可以通过在文件顶部写入数组形状来删除此约束，如下所示：

var A: [1..5, 1..5] real;

[(i,j) in A.domain] A[i,j] = i + 10*j;

var writer = open('dense.txt', iomode.cw).writer();

writer.writeln(A.shape);
writer.write(A);

writer.close();

var reader = open('dense.txt', iomode.r).reader();
var shape: 2*int;
reader.read(shape);
var B: [1..shape[1], 1..shape[2]] real;
reader.read(B);
reader.close();

assert(A == B);

现在，dense.txt看起来是这样的：

(5, 5)
11.0 21.0 31.0 41.0 51.0
12.0 22.0 32.0 42.0 52.0
13.0 23.0 33.0 43.0 53.0
14.0 24.0 34.0 44.0 54.0
15.0 25.0 35.0 45.0 55.0

稀疏阵列I/O

稀疏数组需要做更多的工作，因为DefaultSparse数组(稀疏教堂数组的默认type )只提供.writeThis(f)方法，而不提供Chapel 1.16预发布时的.readThis(f)方法。这意味着我们有编写稀疏数组的内置支持，但不支持读取它们。

由于您专门请求csv格式，所以我们将在csv中执行稀疏数组：

// Create parent domain, sparse subdomain, and sparse array
const D = {1..10, 1..10};
var spD: sparse subdomain(D);
var A: [spD] real;

// Add some non-zeros:
spD += [(1,1), (1,5), (2,7), (5, 4), (6, 6), (9,3), (10,10)];

// Set non-zeros to 1.0 (to make things interesting?)
A = 1.0;

var writer = open('sparse.csv', iomode.cw).writer();

// Write shape
writer.writef('%n,%n\n', A.shape[1], A.shape[2]);

// Iterate over non-zero indices, writing: i,j,value
for (i,j) in spD {
  writer.writef('%n,%n,%n\n', i, j, A[i,j]);
}

writer.close();

var reader = open('sparse.csv', iomode.r).reader();

// Read shape
var shape: 2*int;
reader.readf('%n,%n', shape[1], shape[2]);

// Create parent domain, sparse subdomain, and sparse array
const Bdom = {1..shape[1], 1..shape[2]};
var spBdom: sparse subdomain(Bdom);
var B: [spBdom] real;

// This is an optimization that bulk-adds the indices. We could instead add
// the indices directly to spBdom and the value to B[i,j] each iteration
var indices: [1..0] 2*int,
    values: [1..0] real;

// Variables to be read into
var i, j: int,
    val: real;
while reader.readf('%n,%n,%n', i, j, val) {
  indices.push_back((i,j));
  values.push_back(val);
}

// bulk add the indices to spBdom and add values to B element-wise
spBdom += indices;
for (ij, v) in zip(indices, values) {
  B[ij] = v;
}

reader.close();

// Sparse arrays can't be zippered with anything other than their domains and
// sibling arrays, so we need to do an element-wise assertion:
assert(A.domain == B.domain);
for (i,j) in A.domain {
  assert(A[i,j] == B[i,j]);
}

sparse.csv看起来是这样的：

10,10
1,1,1
1,5,1
2,7,1
5,4,1
6,6,1
9,3,1
10,10,1

MatrixMarket模块

最后，我将提到有一个MatrixMarket包模块，它支持使用矩阵市场格式的密集和稀疏数组I/O。这目前没有显示在公共文档中，因为一旦包管理器足够可靠，它将作为一个独立的包移出，但是您现在可以在您的礼拜堂项目中使用它。

下面是源代码，它包括作为注释的接口文档。

这里是测试，如果您更喜欢学习示例，而不是文档和源代码。

Answer 2

向教授致敬。鲁道夫·齐特尼&教授。佩特·沃普卡

​

(如果你碰巧记得PC工具实用程序，也就是由教授开创和编写的矩阵工具。对于大规模F77有限元矩阵的智能抽象表示，使用COMMON-block和大型稀疏矩阵高效存储和操作在数值处理项目中的类似技巧，Zitny同样不可或缺.)

观察：

我完全不同意最后一种说法，即需要“框架”，以建立一个稀疏的矩阵。

矩阵总是某种形式主义的interpretation。

虽然稀疏矩阵在矩阵上共享相同的视图，但作为解释，这些模块的实现总是严格基于一些具体的representation.。

不同类型的稀疏性总是使用不同的单元格布局策略来处理(诀窍是对单元元素使用最低需要的[SPACE]，而在试图对这样的矩阵执行经典的矩阵/向量操作时，却有一些可接受的处理[TIME]开销(通常不需要用户知道或“手动”干扰底层稀疏矩阵表示，该表示用于存储单元格值，以及如何优化解码/转换为目标-稀疏-矩阵的表示)。

从视觉上讲，矩阵工具将向您展示每个representations尽可能紧凑的内存布局(非常类似于它压缩了硬盘、放置扇区数据的PC工具，以避免任何不必要的、非连续的HDD容量被浪费)，而representation-aware处理程序(特定类型的特定类型)将为任何外部观察者提供假设的矩阵interpretation (在计算阶段)所需的完全错觉。

首先，让我们认识到，对于稀疏矩阵representation，(源端( python-?，JSON-meta-有效载荷-？等)和礼拜堂目标端( LinearAlgebra ver-1.16被确认为不公开( W.I.P. ) )，不知道平台特定规则的所有细节，因此没有什么需要开始实施的。

实际的稀疏矩阵( materialisation )稀疏矩阵representation (无论是file://、DMA访问还是CSP-通道，或者非InRAM存储或InRAM内存映射的任何其他方式)并不会改变交叉表示xlator (单比特)的解决方案。

作为一个矩阵主义者，你可能喜欢representation这一概念，它不是由Cantor集驱动的(遇到(几乎)无限的、密集的枚举)对象，而是使用Vopenka的替代集合论(Vopenka的替代集合论(Vopenka‘situations )(Vopenka的“科学基础的思考”中的历史和数学背景都是如此可爱)的概念)，它以一个尚未改变的定义视野(不仅由于观察者视图的实际敏锐，而且在更广泛和一般意义上的这样一个原则)，使人们对这些情况有了更近的认识。留下pi类和西格玛级的半集，以便继续处理新出现的细节，因为它们进入了我们认识到的(一旦出现在定义视野的“前面”)关于观察(和数学)现象的观点中。

稀疏矩阵(作为representation )帮助我们构建我们所需要的interpretation，以便在进一步处理“作为一个矩阵”时使用迄今已获得的数据单元。

这就是说，工作流总是需要先验地知道：

在稀疏矩阵源系统的representation中使用的约束和规则(a)

b)中介通道施加的附加约束(表现性、格式、自愈/容易出错)，而不管它是文件、CSP-通道还是ZeroMQ / nanomsg智能套接字信令/消息平面分布式代理基础结构。

在目标系统的representation，设置规则中施加的约束和规则，用于定义/加载/存储/进一步处理和计算在目标计算生态系统中选择的稀疏矩阵类型必须满足/遵循的约束和规则。

不知道interpretation a)将在为一个成功和高效的跨表示管道(即从源端representation转换到b)的策略的准备上引入不必要的大型管理费用。忽视b)'s-mediated (C)总是会导致惩罚在target-representation.的沟通重建过程中在目标生态系统中支付额外的间接费用。