我正在研究一个需要操纵巨大矩阵的项目,特别是用于copula计算的金字塔总和。

简而言之,我需要在矩阵(多维数组)中的零海中跟踪相对较少数量的值(通常值为1,在极少数情况下大于1)。

稀疏数组允许用户存储少量值,并假设所有未定义的记录都是预设值。 由于实际上不可能将所有值存储在内存中,因此我只需要存储少数非零元素。 这可能是数百万条目。

速度是一个重中之重,我还想在运行时动态选择类中的变量数。

我目前正在使用二进制搜索树(b-tree)来存储条目的系统。 有谁知道更好的系统?

===============>>#1 票数:27 已采纳

对于C ++,地图效果很好。 数百万个对象不会成为问题。 在我的电脑上,1000万件物品花了大约4.4秒,大约57微米。

我的测试应用程序如下:

#include <stdio.h>
#include <stdlib.h>
#include <map>

class triple {
public:
    int x;
    int y;
    int z;
    bool operator<(const triple &other) const {
        if (x < other.x) return true;
        if (other.x < x) return false;
        if (y < other.y) return true;
        if (other.y < y) return false;
        return z < other.z;
    }
};

int main(int, char**)
{
    std::map<triple,int> data;
    triple point;
    int i;

    for (i = 0; i < 10000000; ++i) {
        point.x = rand();
        point.y = rand();
        point.z = rand();
        //printf("%d %d %d %d\n", i, point.x, point.y, point.z);
        data[point] = i;
    }
    return 0;
}

现在要动态选择变量的数量,最简单的解决方案是将索引表示为字符串 ,然后使用字符串作为映射的键。 例如,位于[23] [55]的项目可以通过“23,55”字符串表示。 我们还可以将此解决方案扩展到更高的维度; 例如对于三维,任意索引将看起来像“34,45,56”。 该技术的简单实现如下:

std::map data<string,int> data;
char ix[100];

sprintf(ix, "%d,%d", x, y); // 2 vars
data[ix] = i;

sprintf(ix, "%d,%d,%d", x, y, z); // 3 vars
data[ix] = i;

===============>>#2 票数:19

作为一般建议,使用字符串作为索引的方法实际上非常慢。 更有效但等效的解决方案是使用向量/数组。 绝对没有必要在字符串中写索引。

typedef vector<size_t> index_t;

struct index_cmp_t : binary_function<index_t, index_t, bool> {
    bool operator ()(index_t const& a, index_t const& b) const {
        for (index_t::size_type i = 0; i < a.size(); ++i)
            if (a[i] != b[i])
                return a[i] < b[i];
        return false;
    }
};

map<index_t, int, index_cmp_t> data;
index_t i(dims);
i[0] = 1;
i[1] = 2;
// … etc.
data[i] = 42;

然而,由于在平衡二叉搜索树方面的实现,在实践中使用map通常不是非常有效。 在这种情况下,性能更好的数据结构将是一个哈希表,由std::unordered_map

===============>>#3 票数:11

Boost有一个模板化的BLAS实现,称为uBLAS,包含一个稀疏矩阵。

http://www.boost.org/doc/libs/1_36_0/libs/numeric/ublas/doc/index.htm

===============>>#4 票数:4

索引比较中的小细节。 您需要进行词典比较,否则:

a= (1, 2, 1); b= (2, 1, 2);
(a<b) == (b<a) is true, but b!=a

编辑:所以比较应该是:

return lhs.x<rhs.x
    ? true 
    : lhs.x==rhs.x 
        ? lhs.y<rhs.y 
            ? true 
            : lhs.y==rhs.y
                ? lhs.z<rhs.z
                : false
        : false

===============>>#5 票数:3

Eigen是一个C ++线性代数库,具有稀疏矩阵的实现 它甚至支持针对稀疏矩阵优化的矩阵运算和求解器(LU分解等)。

===============>>#6 票数:3

哈希表具有快速插入和查找。 您可以编写一个简单的哈希函数,因为您知道您只处理整数对作为键。

===============>>#7 票数:2

完整的解决方案列表可以在维基百科中找到。 为方便起见,我引用了以下相关章节。

https://en.wikipedia.org/wiki/Sparse_matrix#Dictionary_of_keys_.28DOK.29

键字典(DOK)

DOK由一个字典组成,该字典将(行,列) - 对映射到元素的值。 字典中缺少的元素被视为零。 该格式适用于以随机顺序逐步构造稀疏矩阵,但在字典顺序中迭代非零值则较差。 一个人通常以这种格式构造矩阵,然后转换为另一种更有效的格式进行处理。[1]

清单清单(LIL)

LIL每行存储一个列表,每个条目包含列索引和值。 通常,这些条目按列索引进行排序,以便更快地查找。 这是另一种适用于增量矩阵构造的格式。[2]

坐标列表(COO)

COO存储(行,列,值)元组的列表。 理想情况下,条目(按行索引,然后是列索引)进行排序,以改善随机访问时间。 这是另一种有利于增量矩阵构造的格式。[3]

压缩稀疏行(CSR,CRS或耶鲁格式)

压缩稀疏行(CSR)或压缩行存储(CRS)格式通过三个(一维)数组表示矩阵M,其分别包含非零值,行的范围和列索引。 它类似于COO,但压缩行索引,因此命名。 该格式允许快速行访问和矩阵向量乘法(Mx)。

===============>>#8 票数:1

实现稀疏矩阵的最好方法是不实现它们 - 至少不是你自己的。 我建议BLAS(我认为它是LAPACK的一部分)可以处理真正巨大的矩阵。

===============>>#9 票数:0

由于只有[a] [b] [c] ... [w] [x] [y] [z]的值才有结果,我们只存储indice本身,而不是几乎无处不在的值1 - 总是相同的+无法哈希它。 注意维度的诅咒存在,建议使用一些已建立的工具NIST或Boost,至少阅读其中的来源以避免不必要的错误。

如果工作需要捕获未知数据集的时间依赖性分布和参数趋势,那么具有单值根的Map或B-Tree可能不实用。 对于所有1个值,我们只能存储indice本身,如果排序(表示的敏感性)可以从属于减少运行时的时域,则进行散列。 由于除了一个以外的非零值很少,因此明显的候选者是您可以轻松理解的任何数据结构。 如果数据集真的是宇宙大小,我建议使用某种自己管理文件/磁盘/持久性的滑动窗口,根据需要将部分数据移动到范围内。 (编写您可以理解的代码)如果您承诺为工作组提供实际解决方案,那么如果不这样做,您将受到消费级操作系统的支配,这些操作系统的唯一目标是将您的午餐带离您。

===============>>#10 票数:0

这是一个相对简单的实现,应该提供合理的快速查找(使用哈希表)以及对行/列中的非零元素的快速迭代。

// Copyright 2014 Leo Osvald
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef UTIL_IMMUTABLE_SPARSE_MATRIX_HPP_
#define UTIL_IMMUTABLE_SPARSE_MATRIX_HPP_

#include <algorithm>
#include <limits>
#include <map>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

// A simple time-efficient implementation of an immutable sparse matrix
// Provides efficient iteration of non-zero elements by rows/cols,
// e.g. to iterate over a range [row_from, row_to) x [col_from, col_to):
//   for (int row = row_from; row < row_to; ++row) {
//     for (auto col_range = sm.nonzero_col_range(row, col_from, col_to);
//          col_range.first != col_range.second; ++col_range.first) {
//       int col = *col_range.first;
//       // use sm(row, col)
//       ...
//     }
template<typename T = double, class Coord = int>
class SparseMatrix {
  struct PointHasher;
  typedef std::map< Coord, std::vector<Coord> > NonZeroList;
  typedef std::pair<Coord, Coord> Point;

 public:
  typedef T ValueType;
  typedef Coord CoordType;
  typedef typename NonZeroList::mapped_type::const_iterator CoordIter;
  typedef std::pair<CoordIter, CoordIter> CoordIterRange;

  SparseMatrix() = default;

  // Reads a matrix stored in MatrixMarket-like format, i.e.:
  // <num_rows> <num_cols> <num_entries>
  // <row_1> <col_1> <val_1>
  // ...
  // Note: the header (lines starting with '%' are ignored).
  template<class InputStream, size_t max_line_length = 1024>
  void Init(InputStream& is) {
    rows_.clear(), cols_.clear();
    values_.clear();

    // skip the header (lines beginning with '%', if any)
    decltype(is.tellg()) offset = 0;
    for (char buf[max_line_length + 1];
         is.getline(buf, sizeof(buf)) && buf[0] == '%'; )
      offset = is.tellg();
    is.seekg(offset);

    size_t n;
    is >> row_count_ >> col_count_ >> n;
    values_.reserve(n);
    while (n--) {
      Coord row, col;
      typename std::remove_cv<T>::type val;
      is >> row >> col >> val;
      values_[Point(--row, --col)] = val;
      rows_[col].push_back(row);
      cols_[row].push_back(col);
    }
    SortAndShrink(rows_);
    SortAndShrink(cols_);
  }

  const T& operator()(const Coord& row, const Coord& col) const {
    static const T kZero = T();
    auto it = values_.find(Point(row, col));
    if (it != values_.end())
      return it->second;
    return kZero;
  }

  CoordIterRange
  nonzero_col_range(Coord row, Coord col_from, Coord col_to) const {
    CoordIterRange r;
    GetRange(cols_, row, col_from, col_to, &r);
    return r;
  }

  CoordIterRange
  nonzero_row_range(Coord col, Coord row_from, Coord row_to) const {
    CoordIterRange r;
    GetRange(rows_, col, row_from, row_to, &r);
    return r;
  }

  Coord row_count() const { return row_count_; }
  Coord col_count() const { return col_count_; }
  size_t nonzero_count() const { return values_.size(); }
  size_t element_count() const { return size_t(row_count_) * col_count_; }

 private:
  typedef std::unordered_map<Point,
                             typename std::remove_cv<T>::type,
                             PointHasher> ValueMap;

  struct PointHasher {
    size_t operator()(const Point& p) const {
      return p.first << (std::numeric_limits<Coord>::digits >> 1) ^ p.second;
    }
  };

  static void SortAndShrink(NonZeroList& list) {
    for (auto& it : list) {
      auto& indices = it.second;
      indices.shrink_to_fit();
      std::sort(indices.begin(), indices.end());
    }

    // insert a sentinel vector to handle the case of all zeroes
    if (list.empty())
      list.emplace(Coord(), std::vector<Coord>(Coord()));
  }

  static void GetRange(const NonZeroList& list, Coord i, Coord from, Coord to,
                       CoordIterRange* r) {
    auto lr = list.equal_range(i);
    if (lr.first == lr.second) {
      r->first = r->second = list.begin()->second.end();
      return;
    }

    auto begin = lr.first->second.begin(), end = lr.first->second.end();
    r->first = lower_bound(begin, end, from);
    r->second = lower_bound(r->first, end, to);
  }

  ValueMap values_;
  NonZeroList rows_, cols_;
  Coord row_count_, col_count_;
};

#endif  /* UTIL_IMMUTABLE_SPARSE_MATRIX_HPP_ */

为简单起见,它是immutable ,但你可以使它变得可变; 如果你想要一个合理有效的“插入”(将零改为非零),请务必将std::vector更改为std::set

===============>>#11 票数:0

我建议你这样做:

typedef std::tuple<int, int, int> coord_t;
typedef boost::hash<coord_t> coord_hash_t;
typedef std::unordered_map<coord_hash_t, int, c_hash_t> sparse_array_t;

sparse_array_t the_data;
the_data[ { x, y, z } ] = 1; /* list-initialization is cool */

for( const auto& element : the_data ) {
    int xx, yy, zz, val;
    std::tie( std::tie( xx, yy, zz ), val ) = element;
    /* ... */
}

为了帮助保持数据稀疏,您可能希望编写unorderd_map的子类,其迭代器会自动跳过(并擦除)值为0的任何项。

  ask by community wiki translate from so

未解决问题?本站智能推荐: