umappp 0.1.2

data/vendor/knncolle/utils/NeighborQueue.hpp

@@ -0,0 +1,94 @@
+#ifndef NEIGHBOR_QUEUE_HPP
+#define NEIGHBOR_QUEUE_HPP
+
+#include <queue>
+#include <vector>
+#include <algorithm>
+
+namespace knncolle {
+
+template<typename INDEX_t, typename DATA_t>
+using neighbor_queue = std::priority_queue<std::pair<DATA_t, INDEX_t> >;
+
+template<typename INDEX_t, typename DISTANCE_t, class QUEUE>
+inline std::vector<std::pair<INDEX_t, DISTANCE_t> > harvest_queue(QUEUE& nearest, bool check_self = false, INDEX_t self_index = 0) {
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > output;
+
+    // If 'check_self=false', then it never enters the !found_self clause below, which is the correct behaviour.
+    bool found_self=!check_self;
+
+    while (!nearest.empty()) {
+        if (!found_self && nearest.top().second==self_index) {
+            nearest.pop();
+            found_self=true;
+            continue;
+        }
+        output.push_back(std::pair<INDEX_t, DISTANCE_t>(nearest.top().second, nearest.top().first));
+        nearest.pop();
+    }
+
+    // We use push_back + reverse to give us sorting in increasing order;
+    // this is nicer than push_front() for std::vectors.
+    std::reverse(output.begin(), output.end());
+
+    // Getting rid of the last entry to get the 'k' nearest neighbors, if
+    // 'self' was not in the queue; this assumes that we searched on the k+1
+    // neighbors. Note that the absence of the self implies that we have at
+    // least 'k + 2' total observations, otherwise we must have picked up the
+    // self_index; thus, we have guaranteed to have gotten 'k+1' non-self hits,
+    // so the pop is always safe.
+    if (check_self && !found_self) {
+        output.pop_back();
+    }
+
+    return output;
+}
+
+/* The NeighborQueue class is a priority queue that contains indices and
+ * distances in decreasing order from the top of the queue. Existing elements
+ * are displaced by incoming elements that have shorter distances, thus making
+ * it a useful data structure for retaining the k-nearest neighbors.
+ */
+template<typename INDEX_t = int, typename DATA_t = double>
+class NeighborQueue {
+public:
+    NeighborQueue(int k) : n_neighbors(k), full(n_neighbors == 0) {}
+
+    NeighborQueue(int k, INDEX_t self) : n_neighbors(k + 1), full(false), check_self(true), self_index(self) {}
+
+    void add(INDEX_t i, DATA_t d) {
+        if (!full) {
+            nearest.push(std::make_pair(d, i));
+            if (static_cast<int>(nearest.size()) == n_neighbors) {
+                full=true;
+            }
+        } else if (d < limit()) {
+            nearest.push(std::make_pair(d, i));
+            nearest.pop();
+        }
+        return;
+    }
+
+    bool is_full() const {
+        return full;
+    }
+
+    DATA_t limit() const {
+        return nearest.top().first;
+   }
+
+    template<typename DISTANCE_t>
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > report() {
+        return harvest_queue<INDEX_t, DISTANCE_t>(nearest, check_self, self_index);
+    } 
+private:
+    int n_neighbors;
+    bool full = false;
+    bool check_self = false;
+    INDEX_t self_index = 0;
+    neighbor_queue<INDEX_t, DATA_t> nearest;
+};
+
+}
+
+#endif

data/vendor/knncolle/utils/distances.hpp

@@ -0,0 +1,98 @@
+#ifndef KNNCOLLE_DISTANCES_HPP
+#define KNNCOLLE_DISTANCES_HPP
+#include <cmath>
+
+/**
+ * @file distances.hpp
+ *
+ * @brief Classes for distance calculations.
+ */
+
+namespace knncolle {
+
+namespace distances {
+
+/**
+ * @brief Compute Euclidean distances between two input vectors.
+ */
+struct Euclidean {
+    /**
+     * @param x Pointer to the array containing the first vector.
+     * @param y Pointer to the array containing the second vector.
+     * @param n Length of both vectors.
+     *
+     * @tparam ITYPE Integer type for the vector length.
+     * @tparam DTYPE Floating point type for the output distance.
+     * @tparam XTYPE Floating point type for the first data vector.
+     * @tparam YTYPE Floating point type for the second data vector.
+     *
+     * @return The squared Euclidean distance between vectors.
+     *
+     * @note 
+     * This should be passed through `normalize()` to obtain the actual Euclidean distance.
+     * We separate out these two steps to avoid the costly root operation when only the relative values are of interest.
+     */
+    template<typename ITYPE = int, typename DTYPE = double, typename XTYPE = DTYPE, typename YTYPE = DTYPE>
+    static DTYPE raw_distance(const XTYPE* x, const YTYPE* y, ITYPE n) {
+        double output = 0;
+        for (ITYPE i = 0; i < n; ++i, ++x, ++y) {
+            output += ((*x) - (*y)) * ((*x) - (*y));
+        }
+        return output;
+    }
+
+    /**
+     * @tparam DTYPE Floating point type for the distance.
+     *
+     * @param raw The value produced by `raw_distance()`.
+     *
+     * @return The square root of `raw`.
+     */
+    template<typename DTYPE = double>
+    static DTYPE normalize(DTYPE raw) {
+        return std::sqrt(raw);
+    }
+};
+
+/**
+ * @brief Compute Manhattan distances between two input vectors.
+ */
+struct Manhattan {
+    /**
+     * @tparam ITYPE Integer type for the vector length.
+     * @tparam DTYPE Floating point type for the output distance.
+     * @tparam XTYPE Floating point type for the first data vector.
+     * @tparam YTYPE Floating point type for the second data vector.
+     *
+     * @param x Pointer to the array containing the first vector.
+     * @param y Pointer to the array containing the second vector.
+     * @param n Length of both vectors.
+     *
+     * @return The Manhattan distance between vectors.
+     */
+    template<typename ITYPE = int, typename DTYPE = double, typename XTYPE = DTYPE, typename YTYPE = DTYPE>
+    static DTYPE raw_distance(const XTYPE* x, const YTYPE* y, ITYPE n) {
+        DTYPE output = 0;
+        for (ITYPE i = 0; i < n; ++i, ++x, ++y) {
+            output += std::abs(*x - *y);
+        }
+        return output;
+    }
+
+    /**
+     * @tparam DTYPE Floating point type for the distance.
+     * @param raw The value produced by `raw_distance()`.
+     *
+     * @return `raw` with no modification.
+     */
+    template<typename DTYPE = double>
+    static DTYPE normalize(DTYPE raw) {
+        return raw;
+    }
+};
+
+}
+
+}
+
+#endif

data/vendor/knncolle/utils/find_nearest_neighbors.hpp

@@ -0,0 +1,112 @@
+#ifndef KNNCOLLE_FIND_NEAREST_NEIGHBORS_HPP
+#define KNNCOLLE_FIND_NEAREST_NEIGHBORS_HPP
+
+#include <vector>
+#include <utility>
+#include <type_traits>
+#include "Base.hpp"
+
+/**
+ * @file find_nearest_neighbors.hpp
+ *
+ * @brief Find nearest neighbors from an existing index.
+ */
+
+namespace knncolle {
+
+/**
+ * List of nearest neighbors for multiple observations.
+ * Each entry corresponds to an observation and contains the nearest neighbors as (index, distance) pairs for that observation.
+ *
+ * @tparam INDEX_t Integer type for the indices.
+ * @tparam DISTANCE_t Floating point type for the distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double> 
+using NeighborList = std::vector<std::vector<std::pair<INDEX_t, DISTANCE_t> > >;
+
+/**
+ * Find the nearest neighbors within a pre-built index.
+ * This is a convenient wrapper around `Base::find_nearest_neighbors` that saves the caller the trouble of writing a loop.
+ *
+ * @tparam INDEX_t Integer type for the indices in the output object.
+ * @tparam DISTANCE_t Floating point type for the distances in the output object
+ * @tparam InputINDEX_t Integer type for the indices in the input index.
+ * @tparam InputDISTANCE_t Floating point type for the distances in the input index.
+ * @tparam QUERY_t Floating point type for the query data in the input index.
+ *
+ * @param ptr Pointer to a `Base` index.
+ * @param k Number of nearest neighbors. 
+ *
+ * @return A `NeighborList` of length equal to the number of observations in `ptr->nobs()`.
+ * Each entry contains the `k` nearest neighbors for each observation, sorted by increasing distance.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename InputINDEX_t, typename InputDISTANCE_t, typename InputQUERY_t> 
+NeighborList<INDEX_t, DISTANCE_t> find_nearest_neighbors(const Base<InputINDEX_t, InputDISTANCE_t, InputQUERY_t>* ptr, int k) {
+    auto n = ptr->nobs();
+    NeighborList<INDEX_t, DISTANCE_t> output(n);
+
+#ifndef KNNCOLLE_CUSTOM_PARALLEL
+    #pragma omp parallel for
+    for (size_t i = 0; i < n; ++i) {
+#else
+    KNNCOLLE_CUSTOM_PARALLEL(n, [&](size_t first, size_t last) -> void {
+    for (size_t i = first; i < last; ++i) {
+#endif        
+        if constexpr(std::is_same<INDEX_t, InputINDEX_t>::value && std::is_same<DISTANCE_t, InputDISTANCE_t>::value) {
+            output[i] = ptr->find_nearest_neighbors(i, k);
+        } else {
+            auto current = ptr->find_nearest_neighbors(i, k);
+            for (const auto& x : current) {
+                output[i].emplace_back(x.first, x.second);
+            }
+        }
+    }
+#ifdef KNNCOLLE_CUSTOM_PARALLEL    
+    });
+#endif
+
+    return output;
+}
+
+/**
+ * Find the nearest neighbors within a pre-built search index.
+ * Here, only the neighbor indices are returned, not the distances.
+ *
+ * @tparam INDEX_t Integer type for the indices in the output object.
+ * @tparam InputINDEX_t Integer type for the indices in the input index.
+ * @tparam InputDISTANCE_t Floating point type for the distances in the input index.
+ * @tparam QUERY_t Floating point type for the query data in the input index.
+ *
+ * @param ptr Pointer to a `Base` index.
+ * @param k Number of nearest neighbors. 
+ *
+ * @return A vector of vectors of length equal to the number of observations in `ptr->nobs()`.
+ * Each vector contains the indices of the `k` nearest neighbors for each observation, sorted by increasing distance.
+ */
+template<typename INDEX_t = int, typename InputINDEX_t, typename InputDISTANCE_t, typename InputQUERY_t> 
+std::vector<std::vector<INDEX_t> > find_nearest_neighbors_index_only(const Base<InputINDEX_t, InputDISTANCE_t, InputQUERY_t>* ptr, int k) {
+    auto n = ptr->nobs();
+    std::vector<std::vector<INDEX_t> > output(n);
+
+#ifndef KNNCOLLE_CUSTOM_PARALLEL
+    #pragma omp parallel for
+    for (size_t i = 0; i < n; ++i) {
+#else
+    KNNCOLLE_CUSTOM_PARALLEL(n, [&](size_t first, size_t last) -> void {
+    for (size_t i = first; i < last; ++i) {
+#endif        
+        auto current = ptr->find_nearest_neighbors(i, k);
+        for (const auto& x : current) {
+            output[i].push_back(x.first);
+        }
+    }
+#ifdef KNNCOLLE_CUSTOM_PARALLEL    
+    });
+#endif
+
+    return output;
+}
+
+}
+
+#endif

data/vendor/powerit/PowerIterations.hpp

@@ -0,0 +1,157 @@
+#ifndef POWERIT_POWERIT_HPP
+#define POWERIT_POWERIT_HPP
+
+#include <algorithm>
+#include <numeric>
+#include <vector>
+#include <cmath>
+#include "aarand/aarand.hpp"
+
+/**
+ * @file powerit.hpp
+ *
+ * @brief Implements some power iterations.
+ */
+
+namespace powerit {
+
+/**
+ * @brief Perform power iterations to find the first eigenvalue/vector.
+ *
+ * Pretty much as it says. 
+ * Given a diagonalizable matrix, this will perform power iterations to find the first eigenvalue and vector.
+ * For example, we can apply this to a covariance matrix to obtain the first principal component.
+ */
+class PowerIterations {
+public:
+    /**
+     * @brief Default parameter settings.
+     */
+    struct Defaults {
+        /**
+         * See `set_iterations()` for details.
+         */
+        static constexpr int iterations = 500;
+
+        /**
+         * See `set_tolerance()` for details.
+         */
+        static constexpr double tolerance = 0.000001;
+    };
+
+    /**
+     * @param i Maximum number of iterations to perform.
+     * Note that the algorithm may converge before reaching this limit.
+     *
+     * @return A reference to this `PowerIterations` object.
+     */
+    PowerIterations& set_iterations(int i = Defaults::iterations) {
+        iterations = i;
+        return *this;
+    }
+
+    /**
+     * @param t Tolerance used to determine convergence.
+     * The error is defined as the L2 norm of the difference between eigenvectors at successive iterations;
+     * if this drops below `t`, we assume that the algorithm has converged.
+     *
+     * @return A reference to this `PowerIterations` object.
+     */
+    PowerIterations& set_tolerance(double t = Defaults::tolerance) {
+        tolerance = t;
+        return *this;
+    }
+
+private:
+    int iterations = Defaults::iterations;
+    double tolerance = Defaults::tolerance;
+
+    template<typename Data>
+    static Data normalize(int ndim, Data* x) {
+        Data ss = 0;
+        for (int d = 0; d < ndim; ++d) {
+            ss += x[d] * x[d];
+        }
+
+        if (ss) {
+            ss = std::sqrt(ss);
+            for (int d = 0; d < ndim; ++d) {
+                x[d] /= ss;
+            }
+        }
+        return ss;
+    }
+
+public:
+    /**
+     * @tparam Data Floating-point type for the data.
+     * @tparam Engine Any C++11-compliant random number generator class.
+     *
+     * @param order Order of the square matrix.
+     * @param[in] x Pointer to an array containing an `order`-by-`order` diagonalizable matrix.
+     * This is assumed to be column-major.
+     * @param[out] output Pointer to an array of length `order`,
+     * to store the output eigenvector.
+     * @param eng Instance of the random number generator.
+     *
+     * @return Pair containing the eigenvalue (first) and the number of iterations required for convergence (second).
+     * The latter is set to -1 if convergence did not occur before the maximum number of iterations specified in `set_iterations()`.
+     */
+    template<class Data, class Engine>
+    std::pair<Data, int> run(size_t order, const Data* x, Data* output, Engine& eng) {
+        // Defining a random starting vector.
+        while (1) {
+            for (int d = 0; d < order - 1; d += 2) {
+                auto sampled = aarand::standard_normal<Data>(eng);
+                output[d] = sampled.first;
+                output[d + 1] = sampled.second;
+            }
+            if (order % 2) {
+                output[order - 1] = aarand::standard_normal<Data>(eng).first;
+            }
+            if (normalize(order, output)) {
+                break;
+            }
+        }
+
+        std::pair<Data, int> stats;
+        auto& l2 = stats.first;
+        stats.second = -1;
+        std::vector<Data> buffer(order);
+
+        // Applying power iterations.
+        for (int i = 0; i < iterations; ++i) {
+            for (size_t j = 0; j < order; ++j) {
+                // As the matrix is symmetric, we can use inner_product.
+                // This technically computes the transpose of the matrix
+                // with the vector, but it's all the same, so whatever.
+                buffer[j] = std::inner_product(output, output + order, x + j * order, static_cast<Data>(0.0));
+            }
+
+            // Normalizing the vector.
+            l2 = normalize(order, buffer.data());
+
+            // We want to know if SIGMA * output = lambda * output, i.e., l2 * buffer = lambda * output.
+            // If we use l2 as a working estimate for lambda, we're basically just testing the difference
+            // between buffer and output. We compute the error and compare this to the tolerance. No need
+            // to normalize as we've already implicitly done that.
+            Data err = 0;
+            for (size_t d = 0; d < order; ++d) {
+                Data diff = buffer[d] - output[d];
+                err += diff * diff;
+            }
+            if (std::sqrt(err) < tolerance) {
+                stats.second = i + 1;
+                break;
+            }
+
+            std::copy(buffer.begin(), buffer.end(), output);
+        }
+
+        return stats;
+    } 
+};
+
+}
+
+#endif

data/vendor/umappp/NeighborList.hpp

@@ -0,0 +1,37 @@
+#ifndef UMAPPP_NEIGHBOR_LIST_HPP
+#define UMAPPP_NEIGHBOR_LIST_HPP
+
+/**
+ * @file NeighborList.hpp
+ *
+ * @brief Defines the `NeighborList` typedef.
+ */
+
+namespace umappp {
+
+/**
+ * @brief Neighbor specification based on index and distance.
+ *
+ * @tparam Float Floating-point type.
+ *
+ * The index refers to the position of the neighboring observation in the dataset.
+ * The statistic can store some statistic related to the neighbor, e.g., distance or probabilities.
+ */ 
+template<typename Float = double>
+using Neighbor =  std::pair<int, Float>;
+
+/**
+ * @brief Lists of neighbors for each observation.
+ *
+ * @tparam Float Floating-point type.
+ *
+ * Each inner vector corresponds to an observation and contains the list of nearest neighbors for that observation.
+ * Neighbors for each observation should be unique - there should be no more than one occurrence of each index in each inner vector.
+ * Also, the inner vector for observation `i` should not contain any `Neighbor` with index `i`.
+ */
+template<typename Float = double>
+using NeighborList = std::vector<std::vector<Neighbor<Float> > >;
+
+}
+
+#endif