void GreyhoundReader::prepared(PointTableRef table)
{
MetadataNode queryNode(table.privateMetadata("greyhound"));
queryNode.add("info", dense(m_info));
queryNode.add("root", m_params.root());
queryNode.add("params", dense(m_params.toJson()));
}
int main()
{
size_t nb_block = 1000;
static const size_t BlockSize = 6;
size_t rows = nb_block*BlockSize, cols = nb_block*BlockSize;
Dense dense(rows,cols,BlockSize);
Sparse sparse(dense);
Blocks<BlockSize> blocks(dense);
utils::Tic<true> ticd("dense");
compute(dense);
ticd.disp();
utils::Tic<true> tics("sparse");
compute(sparse);
tics.disp();
utils::Tic<true> ticb("blocks");
compute(blocks);
ticb.disp();
// std::cout << m << std::endl;
// std::cout << std::endl;
// std::cout << v.transpose() << std::endl;
//r = s * v;
return 0;
}
static void spectralEmbedding_(const WeightedGraph &simGraph, SparseRepresentation matRep, int k, MatrixXd &embeddings, bool normalize = false, bool symmetric = true) {
assert(k >= 1);
// compute the matrix representation of the graph
SparseMatrix<double> rep = matRep(simGraph, false);
// compute its k smallest eigenvectors
VectorXd eigenvalues;
if (symmetric) {
symmetricSparseEigenSolver(rep, "SM", k + 1, simGraph.numberOfVertices(), eigenvalues, embeddings);
} else {
nonSymmetricSparseEigenSolver(rep, "SM", k + 1, simGraph.numberOfVertices(), eigenvalues, embeddings);
}
embeddings = embeddings.block(0, 1, simGraph.numberOfVertices(), k);
// normalize embedding coordinates if necessary
if (normalize) {
for (int i = 0; i < simGraph.numberOfVertices(); i++) {
embeddings.row(i).normalize();
}
}
if (DEBUG_SEPCTRALCLUSTERING) {
cout<<"laplacian: "<<endl<<rep<<endl;
MatrixXd dense(rep);
SelfAdjointEigenSolver<MatrixXd> solver(dense);
cout<<"expected eigenvalues: "<<solver.eigenvalues()<<endl;
cout<<"expected eigenvectors:"<<endl<<solver.eigenvectors().block(0,1,simGraph.numberOfVertices(),k)<<endl;
cout<<"actual eigenvalues: "<<eigenvalues<<endl;
cout<<"actual eigenvectors:"<<endl<<embeddings<<endl<<endl;
}
}
void MapOptimizer::solve (MatrixSf & sparse_out, float tol, size_t max_steps)
{
MatrixXf dense(int(cod.size), int(dom.size));
solve(dense, tol, max_steps);
size_t max_entries = max_entries_heuristic(dense);
sparsify_hard_relative_to_row_col_max(dense, sparse_out, tol, max_entries);
}
TEST(ArraySerializationTest, StrictIntArray) {
AmfInteger v0(0);
AmfInteger v1(1);
AmfInteger v2(2);
AmfInteger v3(3);
std::vector<AmfInteger> dense({{ v0, v1, v2, v3 }});
AmfArray array(dense);
isEqual(v8 {
0x09,
0x09,
0x01,
0x04, 0x00, 0x04, 0x01, 0x04, 0x02, 0x04, 0x03
}, array);
}
void HexGrid::addPoint(Point p)
{
Hexagon *h = findHexagon(p);
if (!h->dense())
{
h->increment();
if (dense(h))
{
h->setDense();
m_miny = std::min(m_miny, h->y() - 1);
if (h->possibleRoot())
{
m_pos_roots.insert(h);
}
markNeighborBelow(h);
}
}
}
void HexGrid::addPoint(Point p)
{
if (m_width < 0)
{
m_sample.push_back(p);
if (m_sample.size() >= m_maxSample)
processSample();
return;
}
Hexagon *h = findHexagon(p);
h->increment();
if (!h->dense())
{
if (dense(h))
{
h->setDense();
m_miny = std::min(m_miny, h->y() - 1);
if (h->possibleRoot())
m_pos_roots.insert(h);
markNeighborBelow(h);
}
}
}
int main(int argc, char* argv[])
{
int input_size = 2;
int dense_size = 3;
Dense dense(dense_size, input_size);
display(dense);
std::vector<float> sum(dense_size);
for(int i = 0; i < dense.dense_size(); ++i) {
sum[i] = (float)i;
}
dense.add(new Relu);
dense.activate_calc(sum);
display(dense);
dense.add(new Softmax);
dense.activate_calc(sum);
display(dense);
return 0;
}
