C++ SparseArray类代码示例

TEST(SparseArrayTest, InsertString) {
    SparseArray<string>* tDString = new SparseArray<string>(3, 3, "default");
    tDString->insert(1, 2, "Sparse");

    EXPECT_EQ("Sparse", tDString->access(1, 2));
    delete tDString;
}

SparseArray SparseMatrix::getColumn(unsigned i) const { 
    SparseArray column;
    for (unsigned j=0; j<numRows(); ++j) {
        int pos = _row[j].findIndex(i);
        if (pos != -1) column.insert(j, _row[j].readValue(pos));
    }
    return column;
}

void SparseMatrix::setColumn(unsigned i, const SparseArray& col) {
    unsigned nnz = col.numNonZeros();
    for (unsigned j=0; j<nnz; ++j) {
        int  index = col.readIndex(j);
        double value = col.readValue(j);
        _row[index].setValue(i, value);
    }
}

SparseArray<T> sparseConvertStorageToStorage(const SparseArray<T> &in)
{
    // Dummy function
    // TODO finish this function when support is required
    AF_ERROR("CPU Backend only supports Dense to CSR or COO", AF_ERR_NOT_SUPPORTED);

    in.eval();

    SparseArray<T> dense = createEmptySparseArray<T>(in.dims(), (int)in.getNNZ(), dest);

    return dense;
}

Array<T> sparseConvertStorageToDense(const SparseArray<T> &in_)
{
    // MKL only has dns<->csr.
    // CSR <-> CSC is only supported if input is square

    if(stype == AF_STORAGE_CSC)
        AF_ERROR("CPU Backend only supports Dense to CSR or COO", AF_ERR_NOT_SUPPORTED);

    in_.eval();

    Array<T> dense_ = createValueArray<T>(in_.dims(), scalar<T>(0));
    dense_.eval();

    auto func = [=] (Array<T> dense, const SparseArray<T> in) {
        // Read: https://software.intel.com/en-us/node/520848
        // But job description is incorrect with regards to job[1]
        // 0 implies row major and 1 implies column major
        int j1 = 1, j2 = 0;
        const int job[] = {1, j1, j2, 2, (int)dense.elements(), 1};

        const int M = dense.dims()[0];
        const int N = dense.dims()[1];

        int ldd = dense.strides()[1];

        int info = 0;

        Array<T  > values = in.getValues();
        Array<int> rowIdx = in.getRowIdx();
        Array<int> colIdx = in.getColIdx();

        // Have to mess up all const correctness because MKL dnscsr function
        // is bidirectional and has input/output on all pointers
        dnscsr_func<T>()(
                job, &M, &N,
                reinterpret_cast<ptr_type<T>>(dense.get()), &ldd,
                reinterpret_cast<ptr_type<T>>(const_cast<T*>(values.get())),
                const_cast<int*>(colIdx.get()),
                const_cast<int*>(rowIdx.get()),
                &info);
    };

    getQueue().enqueue(func, dense_, in_);

    if(stype == AF_STORAGE_CSR)
        return dense_;
    else
        AF_ERROR("CPU Backend only supports Dense to CSR or COO", AF_ERR_NOT_SUPPORTED);

    return dense_;
}

Array<T> sparseConvertCOOToDense(const SparseArray<T> &in)
{
    in.eval();

    Array<T> dense = createValueArray<T>(in.dims(), scalar<T>(0));
    dense.eval();

    const Array<T>   values = in.getValues();
    const Array<int> rowIdx = in.getRowIdx();
    const Array<int> colIdx = in.getColIdx();

    getQueue().enqueue(kernel::coo2dense<T>, dense, values, rowIdx, colIdx);

    return dense;
}

unsigned SparseMatrix::copyCCS(long*& colptr, long*& index, double*& value) const {
	unsigned N = numNonZeros();
	colptr = (long int*) malloc((numColumns() + 1) * sizeof(long int));
	index  = (long int*) malloc(N * sizeof(long int));
	value  = (double*) malloc(N * sizeof(double));
	
	colptr[0] = 0;
	for (unsigned i = 0; i < numColumns(); ++i) {
        SparseArray col = getColumn(i);
		int offset = col.numNonZeros();
        col.copy( &(index[colptr[i]]), &(value[colptr[i]]) );
		colptr[i+1] = colptr[i] + offset;
	}
	return N;
}

TEST(sparseTest, getNumCols) {
  SparseArray<int>* i = new SparseArray<int>(5, 5, 0);
  SparseArray<double>* d = new SparseArray<int>(5, 10, 0);
  SparseArray<std::string>* s = new SparseArray<std::string>(5, 19, 0);

  i->insert(2, 2, 7);
  d->insert(4, 4, 3.145);
  s->insert(0, 0, "Hello");

  EXPECT_EQ(5, i->getNumCols());
  EXPECT_EQ(10, d->getNumCols());
  EXPECT_EQ(19, s->getNumCols());

  delete i;
  delete d;
  delete s;
}

TEST(Sparse, Print) {
	SparseArray<double>* newSparse = new SparseArray<double>(25,25,1.1);
	newSparse->insert(1,2,1.2);
	newSparse->insert(9,8,2.2);
	newSparse->insert(7,2,3.3);
	newSparse->insert(6,4,4.4);
	newSparse->insert(0,8,5.5);
	newSparse->insert(19,14,6.6);
	newSparse->insert(20,20,7.7);
	newSparse->insert(14,6,8.8);
	newSparse->insert(24,24,9.9);
	newSparse->print();
	delete newSparse;
}

double cosSim(const SparseArray& a, const SparseArray& b) {
    double ab = 0, a2 = 0, b2 = 0;
    auto i = a.begin(), j = b.begin();

    while(i != a.end() || j != b.end()) {
        if(i == a.end()) {
            b2 += j->value * j->value;
            ++j;
        } else if(j == b.end()) {
            a2 += i->value * i->value;
            ++i;
        } else if((*i) < (*j)) {
            a2 += i->value * i->value;
            ++i;
        } else if((*j) < (*i)) {
            b2 += j->value * j->value;
            ++j;
        } else {
            a2 += i->value * i->value;
            b2 += j->value * j->value;
            ab += i->value * j->value;
            ++i;
            ++j;
        }
    }

    if(a2 == 0 || b2 == 0) {
        return 1.0;
    } else {
        //cout << "ab=" << ab << " a2=" << a2 << " b2=" << b2 << endl;
        return ab / sqrt(a2*b2);
    }
}

/**
 * Read a topic vector file
 * The format of these files are such that each line is:
 * idx1 idx2 ... idxN ||| val1 val2 ... valN
 * Which represents a coordinate form sparse array
 * @param t Vector to write to
 * @param fname The file name to read from
 */
void readTopicFile(vector<SparseArray>& t, const char *fname) {
    cerr << "Reading " << fname << endl;
    int linesRead = 1;
    ifstream topic1file(fname,ifstream::in);
    if(topic1file.fail()) {
        cerr << "Failed to read " << fname << endl;
        return;
    }
    string line;
    while(getline(topic1file,line)) {
        stringstream ss(line);
        ss.exceptions(ifstream::failbit);
        if(linesRead % 10 == 0) {
            cerr << ".";
        }
        cerr.flush();
        linesRead++;
        SparseArray arr;
        while(ss.peek() != '|') {
            SparseArrayElem e;
            ss >> e.idx;
            arr.push_back(e);
            while(ss.peek() == ' ') {
                ss.get();
            }
        }
        while(ss.peek() == '|' || ss.peek() == ' ') {
            ss.get();
        }
        unsigned vals = 0;
        for(auto it = arr.begin(); it != arr.end(); ++it) {
            if(++vals > arr.size()) {
                throw runtime_error("Index and value length differ (too many values)");
            }
            ss >> it->value;
        }
        if(vals != arr.size()) {
            throw runtime_error("Index and value length differ (too few values)");
        }

        sort(arr.begin(),arr.end());
        t.push_back(arr);
    }
    cerr << "OK" << endl;
}

Test(sparseTest, remove) {
  SparseArray<int>* i = new SparseArray<int>(5, 5, 0);
  SparseArray<double>* d = new SparseArray<int>(5, 5, 0);
  SparseArray<std::string>* s = new SparseArray<std::string>(5, 5, "o");
  
  i->insert(2, 2, 7);
  d->insert(4, 4, 3.145);
  s->insert(0, 0, "Hello");
  i->insert(3, 3, 9);
  
  i->remove(2, 2);
  d->remove(4, 4);
  s->remove(0, 0);

  s->insert(0, 0, "y");

  EXPECT_EQ(0, i->access(2, 2));
  EXPECT_EQ(0, d->access(4, 4));
  EXPECT_EQ("y", s->access(0, 0));
  EXPECT_EQ(9, i->insert(3, 3));

  delete i;
  delete d;
  delete s;
}