abcpp 1.0.0__tar.gz

abcpp-1.0.0/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.15...3.27)
+project(abcpp_python CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(MSVC)
+    add_compile_options(/utf-8 /W3 /wd4267)
+endif()
+
+find_package(pybind11 CONFIG REQUIRED)
+
+if(NOT TARGET abcpp)
+    add_library(abcpp STATIC
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/abc.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/linear_algebra.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/matrix.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/options.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/reduction.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/result.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/statistics.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/src/summary.cpp
+    )
+    set_property(TARGET abcpp PROPERTY POSITION_INDEPENDENT_CODE ON)
+    target_include_directories(abcpp PUBLIC
+        ${CMAKE_CURRENT_LIST_DIR}/Cpp/include
+    )
+endif()
+
+pybind11_add_module(_core MODULE src/py_abcpp.cpp)
+target_link_libraries(_core PRIVATE abcpp)
+
+install(TARGETS _core DESTINATION abcpp)

abcpp-1.0.0/Cpp/include/abcpp/abc.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "abcpp/matrix.hpp"
+#include "abcpp/options.hpp"
+#include "abcpp/result.hpp"
+
+#include <string>
+#include <vector>
+
+namespace abcpp {
+
+class opt {
+public:
+    opt() = default;
+
+    opt& set_target(const Matrix& target);
+    opt& set_params(const Matrix& params);
+    opt& set_sumstats(const Matrix& sumstats);
+
+    opt& set_method(method value);
+    opt& set_tol(double value);
+    opt& set_kernel(kernel value);
+    opt& set_hcorr(bool value);
+    opt& set_transform(transform value);
+    opt& set_prior_weights(const std::vector<double>& value);
+    opt& set_seed(unsigned int value);
+
+    opt& set_nnet_numnet(int value);
+    opt& set_nnet_sizenet(int value);
+    opt& set_nnet_lambda(const std::vector<double>& value);
+    opt& set_nnet_maxit(int value);
+    opt& set_nnet_rang(double value);
+    opt& set_nnet_abstol(double value);
+    opt& set_nnet_reltol(double value);
+    opt& set_nnet_verbose(bool value);
+    opt& set_nnet_skip(bool value);
+
+    result run() const;
+
+private:
+    Matrix target_;
+    Matrix params_;
+    Matrix sumstats_;
+    bool has_target_ = false;
+    bool has_params_ = false;
+    bool has_sumstats_ = false;
+    options options_;
+};
+
+result fit(
+    const std::vector<double>& target,
+    const Matrix& param,
+    const Matrix& sumstat,
+    const options& options
+);
+
+result fit(
+    const Matrix& target,
+    const Matrix& param,
+    const Matrix& sumstat,
+    const options& options
+);
+
+result fit(
+    const Matrix& target,
+    const Matrix& param,
+    const std::vector<Matrix>& sumstats,
+    const options& options
+);
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/abcpp.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "abcpp/abc.hpp"
+#include "abcpp/matrix.hpp"
+#include "abcpp/options.hpp"
+#include "abcpp/result.hpp"
+#include "abcpp/summary.hpp"
+
+#ifdef ABCPP_IMPLEMENTATION
+#include "abcpp/abcpp_impl.hpp"
+#endif

abcpp-1.0.0/Cpp/include/abcpp/linear_algebra.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "abcpp/matrix.hpp"
+
+#include <vector>
+
+namespace abcpp {
+
+Matrix transpose(const Matrix& matrix);
+
+Matrix multiply(const Matrix& left, const Matrix& right);
+
+std::vector<double> multiply(
+    const Matrix& matrix,
+    const std::vector<double>& vector
+);
+
+Matrix add_intercept(const Matrix& x);
+
+std::vector<double> solve_linear_system(
+    Matrix a,
+    std::vector<double> b
+);
+
+Matrix inverse(Matrix matrix);
+
+Matrix weighted_least_squares(
+    const Matrix& design,
+    const Matrix& response,
+    const std::vector<double>& weights,
+    double ridge_lambda
+);
+
+Matrix predict(const Matrix& design, const Matrix& coefficients);
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/matrix.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <cstddef>
+#include <stdexcept>
+#include <vector>
+
+namespace abcpp {
+
+class Matrix {
+public:
+    Matrix();
+
+    Matrix(
+        std::size_t rows,
+        std::size_t cols,
+        double value = 0.0
+    );
+
+    std::size_t rows() const;
+
+    std::size_t cols() const;
+
+    bool empty() const;
+
+    double& operator()(std::size_t row, std::size_t col);
+
+    double operator()(std::size_t row, std::size_t col) const;
+
+    std::vector<double>& data();
+
+    const std::vector<double>& data() const;
+
+    std::vector<double> row(std::size_t index) const;
+
+    std::vector<double> col(std::size_t index) const;
+
+    void set_row(std::size_t index, const std::vector<double>& values);
+
+private:
+    std::size_t rows_ = 0;
+    std::size_t cols_ = 0;
+    std::vector<double> data_;
+};
+
+Matrix from_row_major(
+    const std::vector<double>& values,
+    std::size_t rows,
+    std::size_t cols
+);
+
+Matrix subset_rows(
+    const Matrix& matrix,
+    const std::vector<std::size_t>& rows
+);
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/options.hpp

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "abcpp/matrix.hpp"
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace abcpp {
+
+enum class method {
+    rejection,
+    loclinear,
+    ridge,
+    neuralnet
+};
+
+using Method = method;
+using AbcMethod = method;
+
+enum class kernel {
+    gaussian,
+    epanechnikov,
+    rectangular,
+    triangular,
+    biweight,
+    cosine
+};
+
+using Kernel = kernel;
+
+enum class transform {
+    none,
+    log,
+    logit
+};
+
+using Transform = transform;
+
+enum class reduction_method {
+    none,
+    pca,
+    pls
+};
+
+using ReductionMethod = reduction_method;
+
+struct ReductionOptions {
+    reduction_method method = reduction_method::none;
+    std::size_t n_comp = 0;
+};
+
+struct nnet_options {
+    int numnet = 10;
+    int sizenet = 5;
+    std::vector<double> lambda = {0.0001, 0.001, 0.01};
+    int maxit = 500;
+    double rang = 0.7;
+    double abstol = 1e-4;
+    double reltol = 1e-8;
+    bool verbose = false;
+    bool skip = false;
+};
+
+struct options {
+    abcpp::method method = abcpp::method::rejection;
+    double tol = 0.01;
+    abcpp::kernel kernel = abcpp::kernel::epanechnikov;
+    bool hcorr = true;
+    abcpp::transform transf = abcpp::transform::none;
+    std::vector<abcpp::transform> transformations;
+    Matrix logit_bounds;
+    std::vector<bool> subset;
+    std::vector<double> prior_weights;
+    unsigned int seed = 1004;
+    nnet_options nnet;
+    ReductionOptions reduction;
+};
+
+using AbcOptions = options;
+
+method parse_method(const std::string& value);
+
+kernel parse_kernel(const std::string& value);
+
+transform parse_transform(const std::string& value);
+
+reduction_method parse_reduction(const std::string& value);
+
+std::string method_name(abcpp::method method);
+
+std::string kernel_name(abcpp::kernel kernel);
+
+std::string transform_name(abcpp::transform transform);
+
+std::string reduction_name(reduction_method reduction);
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/reduction.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "abcpp/matrix.hpp"
+#include "abcpp/options.hpp"
+#include "abcpp/result.hpp"
+
+#include <vector>
+
+namespace abcpp {
+
+struct ReducedSummary {
+    Matrix sumstat;
+    std::vector<double> target;
+    ReductionInfo info;
+};
+
+ReducedSummary reduce_summary_statistics(
+    const Matrix& param,
+    const Matrix& sumstat,
+    const std::vector<double>& target,
+    const ReductionOptions& options
+);
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/result.hpp

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "abcpp/matrix.hpp"
+#include "abcpp/options.hpp"
+
+#include <string>
+#include <vector>
+
+namespace abcpp {
+
+struct ReductionInfo {
+    reduction_method method = reduction_method::none;
+    std::size_t n_comp = 0;
+    Matrix rotation;
+    std::vector<double> center;
+};
+
+struct AbcDiagnostics {
+    double aic = 0.0;
+    double bic = 0.0;
+    std::vector<double> lambda;
+};
+
+struct AbcResult {
+    Matrix adj_values;
+    Matrix unadj_values;
+    Matrix accepted_sumstats;
+    Matrix weights;
+    Matrix residuals;
+    std::vector<double> distances;
+    std::vector<std::size_t> accepted_indices;
+    std::vector<bool> region;
+    std::vector<bool> na_action;
+    std::vector<transform> transformations;
+    Matrix logit_bounds;
+    abcpp::options options;
+    abcpp::method method = abcpp::method::rejection;
+    abcpp::kernel kernel = abcpp::kernel::epanechnikov;
+    bool hcorr = true;
+    std::vector<double> lambda;
+    int numparam = 0;
+    int numstat = 0;
+    double aic = 0.0;
+    double bic = 0.0;
+    ReductionInfo reduction;
+    std::string status = "ok";
+    std::string message;
+    AbcDiagnostics diagnostics;
+    std::vector<std::string> parameter_names;
+    std::vector<std::string> statistic_names;
+};
+
+using result = AbcResult;
+
+struct SummaryColumn {
+    double min = 0.0;
+    double q_lower = 0.0;
+    double median = 0.0;
+    double mean = 0.0;
+    double mode = 0.0;
+    double q_upper = 0.0;
+    double max = 0.0;
+    double sd = 0.0;
+};
+
+struct SummaryResult {
+    std::vector<SummaryColumn> columns;
+    double interval = 0.95;
+    bool unadjusted = false;
+};
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/statistics.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "abcpp/matrix.hpp"
+
+#include <cstddef>
+#include <vector>
+
+namespace abcpp {
+
+bool is_finite(double value);
+
+double median(std::vector<double> values);
+
+double quantile_type7(std::vector<double> values, double probability);
+
+double mad(const std::vector<double>& values);
+
+double mean(const std::vector<double>& values);
+
+double weighted_mean(
+    const std::vector<double>& values,
+    const std::vector<double>& weights
+);
+
+double sample_sd(const std::vector<double>& values);
+
+std::vector<double> column_means(const Matrix& matrix);
+
+std::vector<double> column_mads(
+    const Matrix& matrix,
+    const std::vector<bool>& keep_rows
+);
+
+std::vector<double> column_weighted_sse(
+    const Matrix& matrix,
+    const std::vector<double>& weights
+);
+
+double kernel_mode(
+    const std::vector<double>& values,
+    const std::vector<double>& weights
+);
+
+}  // namespace abcpp

abcpp-1.0.0/Cpp/include/abcpp/summary.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "abcpp/result.hpp"
+
+namespace abcpp {
+
+SummaryResult summary(
+    const AbcResult& result,
+    bool unadjusted = false,
+    double interval = 0.95
+);
+
+SummaryResult summarize(
+    const AbcResult& result,
+    bool unadjusted = false,
+    double interval = 0.95
+);
+
+}  // namespace abcpp