Replace all uintptr_t's with JsFakeInts for consistency.

All other integer inputs are accepted as JsFakeInts and are safely cast within
the function body, so we do the same with the uintptr_t's (which are still
represented as Javascript numbers from _malloc and in the $$.ptrs).

Also fixed a few other things while we're at it, such as making sure all
integers are passed as JsFakeInts, and namespacing the fixed-width types.
In particular, cleaned up the NeighborResults constructor.

Author: LTLA

src/NeighborIndex.cpp

@@ -40,28 +40,31 @@ std::unique_ptr<knncolle::Builder<std::int32_t, double, double, knncolle::Simple
     }
 }
 
-NeighborIndex build_neighbor_index(std::uintptr_t mat, JsFakeInt nr_raw, JsFakeInt nc_raw, bool approximate) {
+NeighborIndex build_neighbor_index(JsFakeInt mat_raw, JsFakeInt nr_raw, JsFakeInt nc_raw, bool approximate) {
     auto builder = create_builder(approximate);
     NeighborIndex output;
-    const double* ptr = reinterpret_cast<const double*>(mat);
-    output.index = builder->build_unique(knncolle::SimpleMatrix<std::int32_t, double>(js2int<std::size_t>(nr_raw), js2int<std::int32_t>(nc_raw), ptr));
+    const auto nr = js2int<std::size_t>(nr_raw);
+    const auto nc = js2int<std::int32_t>(nc_raw);
+    const double* ptr = reinterpret_cast<const double*>(js2int<std::uintptr_t>(mat_raw));
+    output.index = builder->build_unique(knncolle::SimpleMatrix<std::int32_t, double>(nr, nc, ptr));
     return output;
 }
 
 NeighborResults find_nearest_neighbors(const NeighborIndex& index, JsFakeInt k_raw, JsFakeInt nthreads_raw) {
-    NeighborResults output;
-    output.neighbors = knncolle::find_nearest_neighbors(*(index.index), js2int<int>(k_raw), js2int<int>(nthreads_raw));
-    return output;
+    return NeighborResults(knncolle::find_nearest_neighbors(*(index.index), js2int<int>(k_raw), js2int<int>(nthreads_raw)));
 }
 
-NeighborResults truncate_nearest_neighbors(const NeighborResults& original, JsFakeInt k_raw) {
+NeighborResults truncate_nearest_neighbors(const NeighborResults& input, JsFakeInt k_raw) {
     NeighborResults output;
-    const auto nobs = original.neighbors.size();
-    output.neighbors.resize(nobs);
+    const auto nobs = input.neighbors().size();
+    auto& out_neighbors = output.neighbors();
+    sanisizer::resize(out_neighbors, nobs);
+
+    auto& in_neighbors = input.neighbors();
     const auto desired = js2int<int>(k_raw);
     for (I<decltype(nobs)> i = 0; i < nobs; ++i) {
-        const auto& current = original.neighbors[i];
-        auto& curout = output.neighbors[i];
+        const auto& current = in_neighbors[i];
+        auto& curout = out_neighbors[i];
         const auto size = sanisizer::min(current.size(), desired);
         curout.insert(curout.end(), current.begin(), current.begin() + size);
     }
@@ -80,7 +83,7 @@ EMSCRIPTEN_BINDINGS(build_neighbor_index) {
         .function("num_dim", &NeighborIndex::num_dim, emscripten::return_value_policy::take_ownership());
 
     emscripten::class_<NeighborResults>("NeighborResults")
-        .constructor<size_t, uintptr_t, uintptr_t, uintptr_t>()
+        .constructor<JsFakeInt, JsFakeInt, JsFakeInt, JsFakeInt>()
         .function("num_obs", &NeighborResults::num_obs, emscripten::return_value_policy::take_ownership())
         .function("num_neighbors", &NeighborResults::num_neighbors, emscripten::return_value_policy::take_ownership())
         .function("size", &NeighborResults::size, emscripten::return_value_policy::take_ownership())

src/NeighborIndex.h

@@ -23,63 +23,105 @@ struct NeighborIndex {
 
 std::unique_ptr<knncolle::Builder<std::int32_t, double, double, knncolle::SimpleMatrix<std::int32_t, double> > > create_builder(bool);
 
-struct NeighborResults { 
-    typedef std::vector<std::vector<std::pair<int32_t, double> > > Neighbors;
+class NeighborResults { 
+    typedef std::vector<std::vector<std::pair<std::int32_t, double> > > Neighbors;
 
-    Neighbors neighbors;
+    Neighbors my_neighbors;
 
 public:
-    NeighborResults(size_t n = 0) : neighbors(n) {}
+    NeighborResults() = default;
 
-    NeighborResults(size_t n, uintptr_t runs, uintptr_t indices, uintptr_t distances) : neighbors(n) {
-        auto rptr = reinterpret_cast<const int32_t*>(runs);
-        auto iptr = reinterpret_cast<const int32_t*>(indices);
+    NeighborResults(Neighbors neighbors) : my_neighbors(std::move(neighbors)) {}
+
+    NeighborResults(JsFakeInt n_raw, JsFakeInt runs_raw, JsFakeInt indices_raw, JsFakeInt distances_raw) : 
+        my_neighbors(js2int<I<decltype(my_neighbors.size())> >(n_raw))
+    {
+        const auto runs = js2int<std::uintptr_t>(runs_raw);
+        auto rptr = reinterpret_cast<const std::int32_t*>(runs);
+
+        const auto indices = js2int<std::uintptr_t>(indices_raw);
+        auto iptr = reinterpret_cast<const std::int32_t*>(indices);
+
+        const auto distances = js2int<std::uintptr_t>(distances_raw);
         auto dptr = reinterpret_cast<const double*>(distances);
 
-        for (size_t i = 0; i < n; ++i) {
-            neighbors[i].reserve(rptr[i]);
-            for (int32_t j = 0; j < rptr[i]; ++j, ++iptr, ++dptr) {
-                neighbors[i].emplace_back(*iptr, *dptr);
+        const auto n = my_neighbors.size();
+        for (I<decltype(n)> i = 0; i < n; ++i) {
+            const auto run = rptr[i];
+            auto& nn = my_neighbors[i];
+            nn.reserve(run);
+
+            for (I<decltype(run)> j = 0; j < run; ++j) {
+                nn.emplace_back(iptr[j], dptr[j]);
             }
+
+            iptr += run;
+            dptr += run;
         }
     }
 
 public:
-    double size(int32_t truncate) const {
-        size_t out = 0;
-        size_t long_truncate = truncate;
-        for (const auto& current : neighbors) {
-            out += std::min(long_truncate, current.size());
+    Neighbors& neighbors() {
+        return my_neighbors;
+    }
+
+    const Neighbors& neighbors() const {
+        return my_neighbors;
+    }
+
+public:
+    JsFakeInt size(JsFakeInt truncate_raw) const {
+        std::size_t out = 0;
+        if (truncate_raw < 0) {
+            for (const auto& current : my_neighbors) {
+                out = sanisizer::sum<std::size_t>(out, current.size());
+            }
+        } else {
+            const auto truncate = js2int<std::size_t>(truncate_raw);
+            for (const auto& current : my_neighbors) {
+                out = sanisizer::sum<std::size_t>(out, sanisizer::min(truncate, current.size()));
+            }
         }
-        return static_cast<double>(out);
+        return int2js(out);
     }
 
-    double num_obs() const {
-        return static_cast<double>(neighbors.size());
+    JsFakeInt num_obs() const {
+        return int2js(my_neighbors.size());
     }
 
-    double num_neighbors() const {
-        return (neighbors.empty() ? 0 : neighbors.front().size());
+    JsFakeInt num_neighbors() const {
+        return int2js(my_neighbors.empty() ? 0 : my_neighbors.front().size());
     }
 
-    void serialize(uintptr_t runs, uintptr_t indices, uintptr_t distances, int32_t truncate) const {
+    void serialize(JsFakeInt runs_raw, JsFakeInt indices_raw, JsFakeInt distances_raw, JsFakeInt truncate_raw) const {
+        const auto runs = js2int<std::uintptr_t>(runs_raw);
         auto rptr = reinterpret_cast<int32_t*>(runs);
+
+        const auto indices = js2int<std::uintptr_t>(indices_raw);
         auto iptr = reinterpret_cast<int32_t*>(indices);
+
+        const auto distances = js2int<std::uintptr_t>(distances_raw);
         auto dptr = reinterpret_cast<double*>(distances);
 
-        size_t long_truncate = truncate;
-        for (const auto& current : neighbors) {
-            size_t nkeep = std::min(long_truncate, current.size());
+        const bool do_truncate = truncate_raw >= 0;
+        const auto truncate = (do_truncate ? js2int<std::size_t>(truncate_raw) : 0);
+
+        for (const auto& current : my_neighbors) {
+            auto nkeep = current.size();
+            if (do_truncate && truncate < nkeep) {
+                nkeep = truncate;
+            }
             *rptr = nkeep;
             ++rptr;
 
-            for (int32_t i = 0; i < nkeep; ++i) {
+            for (I<decltype(nkeep)> i = 0; i < nkeep; ++i) {
                 const auto& x = current[i];
-                *iptr = x.first;
-                *dptr = x.second;
-                ++iptr;
-                ++dptr;
+                iptr[i] = x.first;
+                dptr[i] = x.second;
             }
+
+            iptr += nkeep;
+            dptr += nkeep;
         }
     }
 };

src/NumericMatrix.cpp

@@ -43,7 +43,8 @@ JsFakeInt NumericMatrix::ncol_js() const {
     return int2js(my_ptr->ncol());
 }
 
-void NumericMatrix::row(JsFakeInt r_raw, std::uintptr_t values) {
+void NumericMatrix::row(JsFakeInt r_raw, JsFakeInt values_raw) {
+    const auto values = js2int<std::uintptr_t>(values_raw);
     MatrixValue* buffer = reinterpret_cast<MatrixValue*>(values);
     if (!my_by_row) {
         my_by_row = my_ptr->dense_row();
@@ -53,7 +54,8 @@ void NumericMatrix::row(JsFakeInt r_raw, std::uintptr_t values) {
     return;
 }
 
-void NumericMatrix::column(JsFakeInt c_raw, std::uintptr_t values) {
+void NumericMatrix::column(JsFakeInt c_raw, JsFakeInt values_raw) {
+    const auto values = js2int<std::uintptr_t>(values_raw);
     MatrixValue* buffer = reinterpret_cast<MatrixValue*>(values);
     if (!my_by_column) {
         my_by_column = my_ptr->dense_column();

src/NumericMatrix.h

@@ -32,9 +32,9 @@ class NumericMatrix {
     // Not thread-safe! by_row and by_column are initialized
     // on demand when particular rows and columns are requested
     // in Javascript. Don't use these functions from C++.
-    void row(JsFakeInt r, std::uintptr_t values);
+    void row(JsFakeInt r, JsFakeInt values_raw);
 
-    void column(JsFakeInt c, std::uintptr_t values);
+    void column(JsFakeInt c, JsFakeInt values_raw);
 
 public:
     const std::shared_ptr<const tatami::Matrix<MatrixValue, MatrixIndex> >& ptr() const;

src/aggregate_across_cells.cpp

@@ -30,8 +30,8 @@ class AggregateAcrossCellsResults {
         return emscripten::val(emscripten::typed_memory_view(my_ngenes, my_store.sums[i].data()));
     }
 
-    void all_sums(std::uintptr_t output) const {
-        auto optr = reinterpret_cast<double*>(output);
+    void all_sums(JsFakeInt output_raw) const {
+        auto optr = reinterpret_cast<double*>(js2int<std::uintptr_t>(output_raw));
         for (const auto& ss : my_store.sums) {
             std::copy_n(ss.begin(), my_ngenes, optr);
             optr += my_ngenes;
@@ -43,19 +43,19 @@ class AggregateAcrossCellsResults {
         return emscripten::val(emscripten::typed_memory_view(my_ngenes, my_store.detected[i].data()));
     }
 
-    void all_detected(std::uintptr_t output) const {
-        auto optr = reinterpret_cast<double*>(output);
+    void all_detected(JsFakeInt output_raw) const {
+        auto optr = reinterpret_cast<double*>(js2int<std::uintptr_t>(output_raw));
         for (const auto& ds : my_store.detected) {
             std::copy_n(ds.begin(), my_ngenes, optr);
             optr += my_ngenes;
         }
     }
 };
 
-AggregateAcrossCellsResults aggregate_across_cells(const NumericMatrix& mat, std::uintptr_t factor, bool average, JsFakeInt nthreads_raw) {
+AggregateAcrossCellsResults aggregate_across_cells(const NumericMatrix& mat, JsFakeInt factor_raw, bool average, JsFakeInt nthreads_raw) {
     scran_aggregate::AggregateAcrossCellsOptions aopt;
     aopt.num_threads = js2int<int>(nthreads_raw);
-    auto fptr = reinterpret_cast<const std::int32_t*>(factor);
+    auto fptr = reinterpret_cast<const std::int32_t*>(js2int<std::uintptr_t>(factor_raw));
     auto store = scran_aggregate::aggregate_across_cells<double, double>(*mat, fptr, aopt);
 
     if (average) {

src/build_snn_graph.cpp

@@ -6,9 +6,9 @@
 #include "NeighborIndex.h"
 #include "build_snn_graph.h"
 
-BuildSnnGraphResult build_snn_graph(const NeighborResults& neighbors, std::string scheme, int32_t nthreads) {
+BuildSnnGraphResult build_snn_graph(const NeighborResults& neighbors, std::string scheme, JsFakeInt nthreads_raw) {
     scran_graph_cluster::BuildSnnGraphOptions opt;
-    opt.num_threads = nthreads;
+    opt.num_threads = js2int<int>(nthreads_raw);
 
     if (scheme == "rank") {
         opt.weighting_scheme = scran_graph_cluster::SnnWeightScheme::RANKED;
@@ -20,7 +20,7 @@ BuildSnnGraphResult build_snn_graph(const NeighborResults& neighbors, std::strin
         throw std::runtime_error("no known weighting scheme '" + scheme + "'");
     }
 
-    return BuildSnnGraphResult(scran_graph_cluster::build_snn_graph(neighbors.neighbors, opt));
+    return BuildSnnGraphResult(scran_graph_cluster::build_snn_graph(neighbors.neighbors(), opt));
 }
 
 EMSCRIPTEN_BINDINGS(build_snn_graph) {

src/cbind.cpp

@@ -9,13 +9,13 @@
 
 #include "tatami/tatami.hpp"
 
-NumericMatrix cbind(JsFakeInt n_raw, std::uintptr_t mats) {
-    const auto n = js2int<std::size_t>(n_raw);
+NumericMatrix cbind(JsFakeInt n_raw, JsFakeInt mats_raw) {
+    const auto mat_ptrs = convert_array_of_offsets<const NumericMatrix*>(n_raw, mats_raw);
+    const auto n = mat_ptrs.size();
     if (n == 0) {
         throw std::runtime_error("need at least one matrix to cbind");
     }
 
-    const auto mat_ptrs = convert_array_of_offsets<const NumericMatrix*>(n, mats);
     std::vector<std::shared_ptr<const tatami::Matrix<double, std::int32_t> > > collected;
     collected.reserve(mat_ptrs.size());
 
@@ -36,13 +36,13 @@ NumericMatrix cbind(JsFakeInt n_raw, std::uintptr_t mats) {
     );
 }
 
-NumericMatrix rbind(JsFakeInt n_raw, std::uintptr_t mats) {
-    const auto n = js2int<std::size_t>(n_raw);
+NumericMatrix rbind(JsFakeInt n_raw, JsFakeInt mats_raw) {
+    const auto mat_ptrs = convert_array_of_offsets<const NumericMatrix*>(n_raw, mats_raw);
+    const auto n = mat_ptrs.size();
     if (n == 0) {
         throw std::runtime_error("need at least one matrix to rbind");
     }
 
-    const auto mat_ptrs = convert_array_of_offsets<const NumericMatrix*>(n, mats);
     std::vector<std::shared_ptr<const tatami::Matrix<double, std::int32_t> > > collected;
     collected.reserve(mat_ptrs.size());
 

src/cluster_kmeans.cpp

@@ -54,7 +54,7 @@ class ClusterKmeansResult {
 };
 
 ClusterKmeansResult cluster_kmeans(
-    std::uintptr_t mat,
+    JsFakeInt mat_raw,
     JsFakeInt nr_raw,
     JsFakeInt nc_raw,
     JsFakeInt k_raw,
@@ -67,7 +67,11 @@ ClusterKmeansResult cluster_kmeans(
     JsFakeInt refine_hw_iterations_raw,
     JsFakeInt nthreads_raw
 ) {
-    kmeans::SimpleMatrix<std::int32_t, double> smat(js2int<std::size_t>(nr_raw), js2int<std::int32_t>(nc_raw), reinterpret_cast<const double*>(mat));
+    kmeans::SimpleMatrix<std::int32_t, double> smat(
+        js2int<std::size_t>(nr_raw),
+        js2int<std::int32_t>(nc_raw),
+        reinterpret_cast<const double*>(js2int<std::uintptr_t>(mat_raw))
+    );
 
     std::unique_ptr<kmeans::Initialize<std::int32_t, double, std::int32_t, double, I<decltype(smat)> > > iptr;
     if (init_method == "random") {

src/compute_clrm1_factors.cpp

@@ -3,9 +3,10 @@
 #include "NumericMatrix.h"
 #include "clrm1.hpp"
 
-void compute_clrm1_factors(const NumericMatrix& mat, std::uintptr_t output, JsFakeInt nthreads_raw) {
+void compute_clrm1_factors(const NumericMatrix& mat, JsFakeInt output_raw, JsFakeInt nthreads_raw) {
     clrm1::Options opt;
     opt.num_threads = js2int<int>(nthreads_raw);
+    const auto output = js2int<std::uintptr_t>(output_raw);
     clrm1::compute(*mat, opt, reinterpret_cast<double*>(output));
 }
 

src/delayed.cpp

@@ -38,12 +38,14 @@ void delayed_arithmetic_scalar(NumericMatrix& x, std::string op, bool right, dou
     x.reset_ptr(std::make_shared<tatami::DelayedUnaryIsometricOperation<double, double, std::int32_t> >(std::move(x.ptr()), std::move(operation)));
 }
 
-void delayed_arithmetic_vector(NumericMatrix& x, std::string op, bool right, JsFakeInt margin_raw, std::uintptr_t ptr, JsFakeInt n_raw) {
+void delayed_arithmetic_vector(NumericMatrix& x, std::string op, bool right, JsFakeInt margin_raw, JsFakeInt ptr_raw, JsFakeInt n_raw) {
     const auto margin = js2int<int>(margin_raw);
     const auto n = js2int<std::size_t>(n_raw);
     if (!sanisizer::is_equal(n, margin == 0 ? x.nrow() : x.ncol())) {
         throw std::runtime_error("inappropriate length of vector for delayed arithmetic");
     }
+
+    const auto ptr = js2int<std::uintptr_t>(ptr_raw);
     auto input = reinterpret_cast<const double*>(ptr);
     std::vector<double> store(input, input + n);