{"text": "// Boost.Geometry - gis-projections (based on PROJ4)\n\n// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.\n\n// This file was modified by Oracle on 2017, 2018.\n// Modifications copyright (c) 2017-2018, Oracle and/or its affiliates.\n// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle.\n\n// Use, modification and distribution is subject to the Boost Software License,\n// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at\n// http://www.boost.org/LICENSE_1_0.txt)\n\n// This file is converted from PROJ4, http://trac.osgeo.org/proj\n// PROJ4 is originally written by Gerald Evenden (then of the USGS)\n// PROJ4 is maintained by Frank Warmerdam\n// PROJ4 is converted to Boost.Geometry by Barend Gehrels\n\n// Last updated version of proj: 5.0.0\n\n// Original copyright notice:\n\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the \"Software\"),\n// to deal in the Software without restriction, including without limitation\n// the rights to use, copy, modify, merge, publish, distribute, sublicense,\n// and/or sell copies of the Software, and to permit persons to whom the\n// Software is furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n// DEALINGS IN THE SOFTWARE.\n\n#ifndef BOOST_GEOMETRY_PROJECTIONS_GOODE_HPP\n#define BOOST_GEOMETRY_PROJECTIONS_GOODE_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace geometry\n{\n\nnamespace srs { namespace par4\n{\n struct goode {}; // Goode Homolosine\n\n}} //namespace srs::par4\n\nnamespace projections\n{\n #ifndef DOXYGEN_NO_DETAIL\n namespace detail { namespace goode\n {\n\n static const double Y_COR = 0.05280;\n static const double PHI_LIM = .71093078197902358062;\n\n // TODO: consider storing references to Parameters instead of copies\n template \n struct par_goode\n {\n sinu_spheroid sinu;\n moll_spheroid moll;\n\n par_goode(Par const& par) : sinu(par), moll(par) {}\n };\n\n template \n inline void s_forward(T& lp_lon, T& lp_lat, T& xy_x, T& xy_y,\n Par const& par, par_goode const& proj_par)\n {\n if (fabs(lp_lat) <= PHI_LIM)\n proj_par.sinu.fwd(lp_lon, lp_lat, xy_x, xy_y);\n else {\n proj_par.moll.fwd(lp_lon, lp_lat, xy_x, xy_y);\n xy_y -= lp_lat >= 0.0 ? Y_COR : -Y_COR;\n }\n }\n\n template \n inline void s_inverse(T& xy_x, T& xy_y, T& lp_lon, T& lp_lat,\n Par const& par, par_goode const& proj_par)\n {\n if (fabs(xy_y) <= PHI_LIM)\n proj_par.sinu.inv(xy_x, xy_y, lp_lon, lp_lat);\n else {\n xy_y += xy_y >= 0.0 ? Y_COR : -Y_COR;\n proj_par.moll.inv(xy_x, xy_y, lp_lon, lp_lat);\n }\n }\n\n // Goode Homolosine\n template \n inline void setup_goode(Par& par)\n {\n par.es = 0.;\n\n // NOTE: The following explicit initialization of sinu projection\n // is not needed because setup_goode() is called before proj_par.sinu\n // is constructed and m_par of parent projection is used.\n\n //proj_par.sinu.m_par.es = 0.;\n //detail::gn_sinu::setup_sinu(proj_par.sinu.m_par, proj_par.sinu.m_proj_parm);\n }\n\n }} // namespace detail::goode\n #endif // doxygen\n\n /*!\n \\brief Goode Homolosine projection\n \\ingroup projections\n \\tparam Geographic latlong point type\n \\tparam Cartesian xy point type\n \\tparam Parameters parameter type\n \\par Projection characteristics\n - Pseudocylindrical\n - Spheroid\n \\par Example\n \\image html ex_goode.gif\n */\n template \n struct goode_spheroid : public detail::base_t_fi, T, Parameters>\n {\n detail::goode::par_goode m_proj_parm;\n\n inline goode_spheroid(const Parameters& par)\n : detail::base_t_fi, T, Parameters>(*this, par)\n , m_proj_parm(setup(this->m_par))\n {}\n\n // FORWARD(s_forward) spheroid\n // Project coordinates from geographic (lon, lat) to cartesian (x, y)\n inline void fwd(T& lp_lon, T& lp_lat, T& xy_x, T& xy_y) const\n {\n detail::goode::s_forward(lp_lon, lp_lat, xy_x, xy_y, this->m_par, this->m_proj_parm);\n }\n\n // INVERSE(s_inverse) spheroid\n // Project coordinates from cartesian (x, y) to geographic (lon, lat)\n inline void inv(T& xy_x, T& xy_y, T& lp_lon, T& lp_lat) const\n {\n detail::goode::s_inverse(xy_x, xy_y, lp_lon, lp_lat, this->m_par, this->m_proj_parm);\n }\n\n static inline std::string get_name()\n {\n return \"goode_spheroid\";\n }\n\n private:\n static Parameters& setup(Parameters& par)\n {\n detail::goode::setup_goode(par);\n return par;\n }\n\n };\n\n #ifndef DOXYGEN_NO_DETAIL\n namespace detail\n {\n\n // Static projection\n BOOST_GEOMETRY_PROJECTIONS_DETAIL_STATIC_PROJECTION(srs::par4::goode, goode_spheroid, goode_spheroid)\n\n // Factory entry(s)\n template \n class goode_entry : public detail::factory_entry\n {\n public :\n virtual base_v* create_new(const Parameters& par) const\n {\n return new base_v_fi, T, Parameters>(par);\n }\n };\n\n template \n inline void goode_init(detail::base_factory& factory)\n {\n factory.add_to_factory(\"goode\", new goode_entry);\n }\n\n } // namespace detail\n #endif // doxygen\n\n} // namespace projections\n\n}} // namespace boost::geometry\n\n#endif // BOOST_GEOMETRY_PROJECTIONS_GOODE_HPP\n", "meta": {"hexsha": "8b3747ded9f262099d6cc6823f76fc7ba867af02", "size": 7335, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/external/boost/boost_1_68_0/boost/geometry/srs/projections/proj/goode.hpp", "max_stars_repo_name": "Bpowers4/turicreate", "max_stars_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11356.0, "max_stars_repo_stars_event_min_datetime": "2017-12-08T19:42:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:55:25.000Z", "max_issues_repo_path": "src/external/boost/boost_1_68_0/boost/geometry/srs/projections/proj/goode.hpp", "max_issues_repo_name": "Bpowers4/turicreate", "max_issues_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2402.0, "max_issues_repo_issues_event_min_datetime": "2017-12-08T22:31:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T19:25:52.000Z", "max_forks_repo_path": "src/external/boost/boost_1_68_0/boost/geometry/srs/projections/proj/goode.hpp", "max_forks_repo_name": "Bpowers4/turicreate", "max_forks_repo_head_hexsha": "73dad213cc1c4f74337b905baea2b3a1e5a0266c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1343.0, "max_forks_repo_forks_event_min_datetime": "2017-12-08T19:47:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T11:31:36.000Z", "avg_line_length": 36.4925373134, "max_line_length": 109, "alphanum_fraction": 0.6291751875, "num_tokens": 1754, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6791787121629466, "lm_q2_score": 0.4416730056646256, "lm_q1q2_score": 0.2999749031844382}} {"text": "#define ARMA_NO_DEBUG\r\n\r\n#include \r\n#include \r\n// [[Rcpp::depends(RcppArmadillo, BH, bigmemory)]]\r\n\r\n#include \r\n#include \r\n\r\nusing namespace Rcpp;\r\nusing namespace arma;\r\n\r\n#include \r\n// [[Rcpp::plugins(cpp11)]]\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calcT0Wsim1 (arma::mat& CvSqrt,arma::mat& weight, arma::vec powV, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int k = CvSqrt.n_rows;\r\n // containers\r\n arma::mat T0s1(nperm,npow);\r\n T0s1.fill(0);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n arma::mat U0tmp = weight % U0;\r\n \r\n for (int j = 0; j < npow; j++) {\r\n if (powV[j] == 0) {\r\n arma::mat tmpU01 = abs(U0tmp);\r\n T0s1(i,j) = tmpU01.max();\r\n } else {\r\n T0s1(i,j) = accu(pow(U0tmp,powV[j]));\r\n }\r\n }\r\n }\r\n Rcpp::List res;\r\n res[\"T0\"] =T0s1;\r\n \r\n return(res);\r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\narma::vec avg_rank(arma::vec x) {\r\n \r\n arma::uvec w = arma::stable_sort_index(x,\"descend\");\r\n R_xlen_t sz = x.size();\r\n arma::vec r(sz);\r\n \r\n for (R_xlen_t n, i = 0; i < sz; i += n) {\r\n n = 1;\r\n while (i + n < sz && x[w[i]] == x[w[i + n]]) ++n;\r\n for (R_xlen_t k = 0; k < n; k++) {\r\n r[w[i + k]] = i + (n + 1) / 2.;\r\n }\r\n }\r\n \r\n return r;\r\n \r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calcT0Wsim3 (arma::mat& CvSqrt,arma::mat& weight, arma::vec powV, arma::vec Tsabs, SEXP pBigMat, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int k = CvSqrt.n_rows;\r\n \r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n arma::mat U0tmp = weight % U0;\r\n \r\n for (int j = 0; j < npow; j++) {\r\n if (powV[j] == 0) {\r\n arma::mat tmpU01 = abs(U0tmp);\r\n T0s(i,j) = tmpU01.max();\r\n } else {\r\n T0s(i,j) = accu(pow(U0tmp,powV[j]));\r\n }\r\n }\r\n }\r\n \r\n T0s = arma::abs(T0s);\r\n \r\n arma::vec minp0(nperm);\r\n arma::vec P0s(nperm);\r\n arma::vec pPerm0(npow);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n \r\n // Calculate p-value\r\n arma::vec T0stmp = T0s.col(i);\r\n int tmp3 = 0;\r\n arma::vec rankarma = avg_rank(T0stmp);\r\n \r\n for( int tt=0 ; tt < nperm ; tt++) {\r\n if( Tsabs(i) <= T0stmp(tt) ) {\r\n tmp3++;\r\n }\r\n \r\n P0s(tt) = (double) rankarma(tt) / (double) nperm;\r\n }\r\n \r\n \r\n if(i == 0) {\r\n minp0 = P0s;\r\n } else {\r\n for( int ii = 0; ii < nperm; ii++) {\r\n if( minp0(ii) > P0s(ii) ) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n pPerm0(i) = (double) tmp3/ (double) nperm;\r\n \r\n }\r\n \r\n return Rcpp::List::create(Rcpp::Named(\"minp0\") = minp0,\r\n Rcpp::Named(\"pPerm0\") = pPerm0 );\r\n \r\n}\r\n\r\n\r\n\r\n\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calcT0Wsim4 (arma::mat& CvSqrt,arma::mat& weight, arma::vec Tsabs, arma::vec powV, SEXP pBigMat, SEXP pBigMat3, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n const int k = CvSqrt.n_rows;\r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n XPtr xpMat3(pBigMat3);\r\n arma::mat minp0_sign = arma::Mat ( (double *)xpMat3->matrix(), xpMat3->nrow(), xpMat3->ncol(), false);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n \r\n for (int k = 0; k < nweight; k++) {\r\n arma::mat weight_tmp = weight.col(k);\r\n arma::mat U0tmp = weight_tmp % U0;\r\n \r\n for (int j = 0; j < npow; j++) {\r\n if (powV[j] == 0) {\r\n arma::mat tmpU01 = abs(U0tmp);\r\n T0s(i,j * nweight + k) = tmpU01.max();\r\n } else {\r\n T0s(i,j * nweight + k) = accu(pow(U0tmp,powV[j]));\r\n }\r\n }\r\n }\r\n }\r\n \r\n for (int k =0; k P0s(ii) ) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n double tmp_pvalue = (double) tmp3 / (double) nperm;\r\n pPerm0(j,k) = tmp_pvalue;\r\n \r\n if (tmp_pvalue <= minP_tmp) {\r\n minP_tmp = tmp_pvalue;\r\n }\r\n }\r\n \r\n int count_pvalue = 0;\r\n for(int j=0; j < nperm; j++) {\r\n if( minP_tmp > minp0(j) ) {\r\n count_pvalue = count_pvalue + 1;\r\n }\r\n }\r\n \r\n pPerm0(npow,k) = (double) (count_pvalue + 1) / (double) (nperm + 1);\r\n \r\n }\r\n \r\n return Rcpp::List::create(Rcpp::Named(\"pPerm0\") = pPerm0,\r\n Rcpp::Named(\"cov\") = cov_res );\r\n \r\n}\r\n\r\n\r\n\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calcT0WsimV3 (arma::mat& CvSqrt,arma::mat& weight, arma::vec powV, SEXP pBigMat, SEXP pBigMat3,int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n const int k = CvSqrt.n_rows;\r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n XPtr xpMat3(pBigMat3);\r\n arma::mat minp0_sign = arma::Mat ( (double *)xpMat3->matrix(), xpMat3->nrow(), xpMat3->ncol(), false);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n \r\n for (int k = 0; k < nweight; k++) {\r\n arma::mat weight_tmp = weight.col(k);\r\n arma::mat U0tmp = weight_tmp % U0;\r\n \r\n for (int j = 0; j < npow; j++) {\r\n if (powV[j] == 0) {\r\n arma::mat tmpU01 = abs(U0tmp);\r\n T0s(i,j * nweight + k) = tmpU01.max();\r\n } else {\r\n T0s(i,j * nweight + k) = accu(pow(U0tmp,powV[j]));\r\n }\r\n }\r\n }\r\n }\r\n \r\n for (int k =0; k xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n XPtr xpMat2(pBigMat2);\r\n arma::mat T1s = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n arma::vec pPerm0(npow);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n \r\n arma::mat subcov(nweight,nweight);\r\n subcov.fill(0);\r\n \r\n subcov = cov.submat(i*nweight,i*nweight,((i+1)*nweight -1),((i+1)*nweight -1));\r\n subcov = subcov.i();\r\n \r\n for (int j =0; j < nperm; j++) {\r\n arma::vec tmp_ts = T0s.row(j);\r\n arma::mat tmp_ts2(1,nweight);\r\n tmp_ts2 = tmp_ts.subvec(i*nweight,((i+1) * nweight -1));\r\n arma::mat tmp = tmp_ts2.t() * subcov * tmp_ts2;\r\n T1s(j,i) = tmp(0,0);\r\n }\r\n }\r\n}\r\n\r\n\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nvoid calc_test_ch_V3(arma::mat& cov,arma::vec & mean, arma::mat& weight, arma::vec powV, SEXP pBigMat, SEXP pBigMat2,int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n \r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n XPtr xpMat2(pBigMat2);\r\n arma::mat T1s = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n arma::vec pPerm0(npow);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n \r\n arma::mat subcov(nweight,nweight);\r\n subcov.fill(0);\r\n \r\n subcov = cov.submat(i*nweight,i*nweight,((i+1)*nweight -1),((i+1)*nweight -1));\r\n subcov = subcov.i();\r\n \r\n arma::mat tmp_mean(1,nweight);\r\n tmp_mean = mean.subvec(i*nweight,((i+1) * nweight -1));\r\n for (int j =0; j < nperm; j++) {\r\n arma::vec tmp_ts = T0s.row(j);\r\n arma::mat tmp_ts2(1,nweight);\r\n \r\n tmp_ts2 = tmp_ts.subvec(i*nweight,((i+1) * nweight -1));\r\n tmp_ts2 = tmp_ts2 - tmp_mean;\r\n arma::mat tmp = tmp_ts2.t() * subcov * tmp_ts2;\r\n T1s(j,i) = tmp(0,0);\r\n }\r\n }\r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nvoid calc_test_pan(arma::mat& cov, arma::mat& weight, arma::vec powV, SEXP pBigMat,SEXP pBigMat2, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n \r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T1s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n XPtr xpMat2(pBigMat2);\r\n arma::mat T2s = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n arma::vec pPerm0(npow);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n \r\n arma::mat subcov(nweight,nweight);\r\n subcov.fill(0);\r\n \r\n subcov = cov.submat(i*nweight,i*nweight,((i+1)*nweight -1),((i+1)*nweight -1));\r\n \r\n for (int j =0; j < nperm; j++) {\r\n arma::vec tmp_ts = T2s.row(j);\r\n arma::mat tmp_ts2(1,nweight);\r\n tmp_ts2 = tmp_ts.subvec(i*nweight,((i+1) * nweight -1));\r\n arma::mat tmp = tmp_ts2.t() * subcov * tmp_ts2;\r\n T1s(j,i) = tmp(0,0);\r\n }\r\n }\r\n}\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\narma::mat calc_test_ts(arma::mat& cov, arma::mat& weight, arma::vec powV, arma::vec Ts) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n \r\n arma::mat Ts2(npow,1);\r\n Ts2.fill(0);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n arma::mat subcov(nweight,nweight);\r\n subcov.fill(0);\r\n \r\n subcov = cov.submat(i*nweight,i*nweight,((i+1)*nweight -1),((i+1)*nweight -1));\r\n \r\n arma::mat tmp_ts2(1,nweight);\r\n tmp_ts2 = Ts.subvec(i*nweight,((i+1)*nweight -1));\r\n arma::mat tmp = tmp_ts2.t() * subcov * tmp_ts2;\r\n Ts2(i,0) = tmp(0,0);\r\n }\r\n \r\n return Ts2;\r\n}\r\n\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\narma::mat calc_test_ts_V3(arma::mat& cov, arma::vec & mean, arma::mat& weight, arma::vec powV, arma::vec Ts) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n \r\n arma::mat Ts2(npow,1);\r\n Ts2.fill(0);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n arma::mat subcov(nweight,nweight);\r\n subcov.fill(0);\r\n \r\n subcov = cov.submat(i*nweight,i*nweight,((i+1)*nweight -1),((i+1)*nweight -1));\r\n subcov = subcov.i();\r\n \r\n arma::mat tmp_mean(1,nweight);\r\n tmp_mean = mean.subvec(i*nweight,((i+1) * nweight -1));\r\n \r\n arma::mat tmp_ts2(1,nweight);\r\n tmp_ts2 = Ts.subvec(i*nweight,((i+1)*nweight -1));\r\n tmp_ts2 = tmp_ts2 - tmp_mean;\r\n \r\n arma::mat tmp = tmp_ts2.t() * subcov * tmp_ts2;\r\n Ts2(i,0) = tmp(0,0);\r\n }\r\n \r\n return Ts2;\r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calc_p_ch (arma::vec powV, arma::vec Tsabs, SEXP pBigMat2, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n \r\n // containers\r\n XPtr xpMat2(pBigMat2);\r\n arma::mat T1s = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n arma::vec minp0(nperm);\r\n arma::vec P0s(nperm);\r\n arma::vec pPerm0(npow);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n \r\n // Calculate p-value\r\n arma::vec T1stmp = T1s.col(i);\r\n int tmp3 = 0;\r\n \r\n arma::vec rankarma = avg_rank(T1stmp);\r\n \r\n for( int tt=0 ; tt < nperm ; tt++) {\r\n if( Tsabs(i) <= T1stmp(tt) ) {\r\n tmp3++;\r\n }\r\n P0s(tt) = (double) rankarma(tt) / (double) nperm;\r\n }\r\n \r\n \r\n if(i == 0) {\r\n minp0 = P0s;\r\n } else {\r\n for( int ii = 0; ii < nperm; ii++) {\r\n if( minp0(ii) > P0s(ii) ) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n pPerm0(i) = (double) tmp3 / (double) nperm;\r\n \r\n }\r\n \r\n return Rcpp::List::create(Rcpp::Named(\"minp0\") = minp0,\r\n Rcpp::Named(\"pPerm0\") = pPerm0 );\r\n \r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calc_p_ch_pan (arma::vec powV, arma::vec Tsabs, SEXP pBigMat, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n \r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T1s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n \r\n arma::vec minp0(nperm);\r\n arma::vec P0s(nperm);\r\n arma::vec pPerm0(npow);\r\n \r\n for (int i = 0; i < npow; i++) {\r\n \r\n // Calculate p-value\r\n arma::vec T1stmp = T1s.col(i);\r\n int tmp3 = 0;\r\n \r\n arma::vec rankarma = avg_rank(T1stmp);\r\n \r\n for( int tt=0 ; tt < nperm ; tt++) {\r\n if( Tsabs(i) <= T1stmp(tt) ) {\r\n tmp3++;\r\n }\r\n P0s(tt) = (double) rankarma(tt) / (double) nperm;\r\n }\r\n \r\n \r\n if(i == 0) {\r\n minp0 = P0s;\r\n } else {\r\n for( int ii = 0; ii < nperm; ii++) {\r\n if( minp0(ii) > P0s(ii) ) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n pPerm0(i) = (double) tmp3 / (double) nperm;\r\n \r\n }\r\n \r\n return Rcpp::List::create(Rcpp::Named(\"minp0\") = minp0,\r\n Rcpp::Named(\"pPerm0\") = pPerm0 );\r\n \r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calc_p_pan (arma::vec Tsabs,SEXP pBigMat,SEXP pBigMat2,SEXP pBigMat3, int nTs,int nweight, int nperm) {\r\n \r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n XPtr xpMat2(pBigMat2);\r\n arma::mat T2s = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n \r\n XPtr xpMat3(pBigMat3);\r\n arma::mat minp0_sign = arma::Mat ( (double *)xpMat3->matrix(), xpMat3->nrow(), xpMat3->ncol(), false);\r\n \r\n \r\n // T0s = arma::abs(T0s);\r\n \r\n arma::vec minp0(nperm);\r\n arma::vec P0s(nperm);\r\n arma::vec pPerm0(nTs);\r\n \r\n \r\n for (int i = 0; i < nTs; i++) {\r\n \r\n // Calculate p-value\r\n arma::vec T1stmp = T0s.col(i);\r\n int tmp3 = 0;\r\n \r\n arma::vec rankarma = avg_rank(T1stmp);\r\n \r\n int minp0_index = i - floor(i/nweight) * nweight;\r\n \r\n for( int tt=0 ; tt < nperm ; tt++) {\r\n if( Tsabs(i) <= T1stmp(tt) ) {\r\n tmp3++;\r\n }\r\n \r\n NumericVector tmp_res;\r\n tmp_res = (double) rankarma(tt) / (double) nperm;\r\n \r\n int p0_sign = -1;\r\n if (minp0_sign(tt,minp0_index) >0) {\r\n p0_sign = 1;\r\n }\r\n \r\n tmp_res = qnorm(1 - tmp_res/2) * p0_sign;\r\n T2s(tt,i) = tmp_res[0];\r\n }\r\n \r\n pPerm0(i) = (double) tmp3 / (double) nperm;\r\n }\r\n \r\n arma::mat cov_res(nTs,nTs);\r\n cov_res.fill(0);\r\n cov_res = arma::cov(T2s);\r\n \r\n return Rcpp::List::create(Rcpp::Named(\"pPerm0\") = pPerm0,\r\n Rcpp::Named(\"cov\") = cov_res );\r\n \r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\narma::vec calc_aSPU (arma::mat p_cov, SEXP pBigMat2, int nperm) {\r\n \r\n // containers\r\n XPtr xpMat2(pBigMat2);\r\n arma::mat minp0 = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n arma::vec res(nperm);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat tmp = minp0.row(i) * p_cov * minp0.row(i).t();\r\n res(i) = tmp(0,0);\r\n }\r\n \r\n return res;\r\n}\r\n\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List daSPU_calcT0Wsim4 (arma::mat& CvSqrt,arma::mat& weight, arma::vec powV, arma::vec Tsabs, SEXP pBigMat, SEXP pBigMat2,SEXP pBigMat3,int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int npow = powV.n_rows;\r\n const int nweight = weight.n_cols;\r\n const int k = CvSqrt.n_rows;\r\n // containers\r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n // containers\r\n XPtr xpMat2(pBigMat2);\r\n arma::mat minp0 = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n // containers\r\n XPtr xpMat3(pBigMat3);\r\n arma::mat minp0_sign = arma::Mat ( (double *)xpMat3->matrix(), xpMat3->nrow(), xpMat3->ncol(), false);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n \r\n for (int k = 0; k < nweight; k++) {\r\n arma::mat weight_tmp = weight.col(k);\r\n arma::mat U0tmp = weight_tmp % U0;\r\n \r\n for (int j = 0; j < npow; j++) {\r\n if (powV[j] == 0) {\r\n arma::mat tmpU01 = abs(U0tmp);\r\n T0s(i,k * npow + j) = tmpU01.max();\r\n } else {\r\n T0s(i,k * npow + j) = accu(pow(U0tmp,powV[j]));\r\n }\r\n }\r\n }\r\n }\r\n \r\n for (int k =0; k P0s(ii) ) {\r\n minp0_tmp(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n pPerm0(i) = (double) tmp3/ (double) nperm;\r\n }\r\n \r\n minp0.col(k) = minp0_tmp;\r\n }\r\n \r\n for (int k = 0; k < nweight; k++) {\r\n for (int i = 0; i 0) {\r\n p0_sign = 1;\r\n }\r\n tmp_res = qnorm(1 - tmp_res/2) * p0_sign;\r\n minp0(i,k) = tmp_res[0];\r\n }\r\n }\r\n \r\n arma::mat cov_res(nweight,nweight);\r\n cov_res.fill(0);\r\n cov_res = arma::cov(minp0);\r\n \r\n return Rcpp::List::create(Rcpp::Named(\"pPerm0\") = pPerm0,\r\n Rcpp::Named(\"cov\") = cov_res );\r\n \r\n \r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\narma::vec daSPU_calc_aSPU (arma::mat p_cov, SEXP pBigMat2, int nperm) {\r\n \r\n // containers\r\n XPtr xpMat2(pBigMat2);\r\n arma::mat minp0 = arma::Mat ( (double *)xpMat2->matrix(), xpMat2->nrow(), xpMat2->ncol(), false);\r\n \r\n arma::vec res(nperm);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat tmp = minp0.row(i) * p_cov * minp0.row(i).t();\r\n res(i) = tmp(0,0);\r\n }\r\n \r\n return res;\r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\nRcpp::List calcT0Wsim2 (arma::mat& CvSqrt,arma::mat& weight, arma::vec pow1, arma::vec pow2, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int n_pow1 = pow1.size();\r\n const int n_pow2 = pow2.size();\r\n const int n_weight = weight.n_cols;\r\n \r\n const int k = CvSqrt.n_rows;\r\n // containers\r\n arma::mat T0s1(n_pow1,n_weight);\r\n T0s1.fill(0);\r\n arma::mat T0s(nperm,n_pow1 * n_pow2);\r\n T0s.fill(0);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n \r\n for (int i2 = 0; i2 < n_weight; i2 ++) {\r\n arma::mat U0tmp = weight.col(i2) % U0;\r\n for (int j1 = 0; j1 < n_pow1; j1++) {\r\n if( pow1[j1] > 0) {\r\n arma::vec tmp1 = pow(U0tmp,pow1[j1]);\r\n double tmp2 = sum(tmp1);\r\n \r\n if( tmp2 > 0 ) {\r\n T0s1(j1,i2) = pow(std::abs(tmp2), 1/pow1[j1]);\r\n } else {\r\n T0s1(j1,i2) = -pow(std::abs(tmp2), 1/pow1[j1]);\r\n }\r\n \r\n } else {\r\n arma::vec tmp1 = abs(U0tmp);\r\n T0s1(j1,i2) = max(tmp1);\r\n }\r\n }\r\n }\r\n \r\n for (int j1 = 0; j1 < n_pow1; j1++) {\r\n for (int j2 = 0; j2 < n_pow2; j2++) {\r\n if (pow2[j2] > 0) {\r\n arma::mat tmp3 = pow(T0s1.row(j1),pow2[j2]);\r\n T0s(i, j2 * n_pow1 + j1) = accu(tmp3);\r\n } else {\r\n T0s(i, j2 * n_pow1 + j1) = max(abs(T0s1.row(j1)));\r\n }\r\n }\r\n }\r\n }\r\n \r\n \r\n Rcpp::List res;\r\n res[\"T0s\"] =T0s;\r\n \r\n return(res);\r\n}\r\n\r\n\r\n\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export()]]\r\narma::vec daSPU_calcT0 (arma::mat& CvSqrt,arma::mat& weight, arma::vec pow1, arma::vec pow2, arma::vec Tsabs,SEXP pBigMat, int nperm) {\r\n \r\n //const int n = X1.n_rows;\r\n const int n_pow1 = pow1.size();\r\n const int n_pow2 = pow2.size();\r\n const int n_pow = n_pow1 * n_pow2;\r\n const int n_weight = weight.n_cols;\r\n \r\n const int k = CvSqrt.n_rows;\r\n // containers\r\n arma::mat T0s1(n_pow1,n_weight);\r\n T0s1.fill(0);\r\n \r\n XPtr xpMat(pBigMat);\r\n arma::mat T0s = arma::Mat ( (double *)xpMat->matrix(), xpMat->nrow(), xpMat->ncol(), false);\r\n \r\n for (int i = 0; i < nperm; i++) {\r\n arma::mat U00 = arma::randn(k,1);\r\n arma::mat U0 = CvSqrt * U00;\r\n \r\n for (int i2 = 0; i2 < n_weight; i2 ++) {\r\n arma::mat U0tmp = weight.col(i2) % U0;\r\n for (int j1 = 0; j1 < n_pow1; j1++) {\r\n if( pow1[j1] > 0) {\r\n arma::vec tmp1 = pow(U0tmp,pow1[j1]);\r\n double tmp2 = sum(tmp1);\r\n \r\n if( tmp2 > 0 ) {\r\n T0s1(j1,i2) = pow(std::abs(tmp2), 1/pow1[j1]);\r\n } else {\r\n T0s1(j1,i2) = -pow(std::abs(tmp2), 1/pow1[j1]);\r\n }\r\n \r\n } else {\r\n arma::vec tmp1 = abs(U0tmp);\r\n T0s1(j1,i2) = max(tmp1);\r\n }\r\n }\r\n }\r\n \r\n for (int j1 = 0; j1 < n_pow1; j1++) {\r\n for (int j2 = 0; j2 < n_pow2; j2++) {\r\n if (pow2[j2] > 0) {\r\n arma::mat tmp3 = pow(T0s1.row(j1),pow2[j2]);\r\n T0s(i, j2 * n_pow1 + j1) = accu(tmp3);\r\n } else {\r\n T0s(i, j2 * n_pow1 + j1) = max(abs(T0s1.row(j1)));\r\n }\r\n }\r\n }\r\n }\r\n \r\n //\r\n T0s = arma::abs(T0s);\r\n \r\n arma::vec minp0(nperm);\r\n arma::vec P0s(nperm);\r\n arma::vec pPerm0(n_pow + 1);\r\n double minP_tmp = 1.0;\r\n\r\n for(int k = 0; k < n_pow; k++) {\r\n \r\n \r\n // Calculate p-value\r\n arma::vec T0stmp = T0s.col(k);\r\n int tmp3 = 0;\r\n arma::vec rankarma = avg_rank(T0stmp);\r\n \r\n for( int tt=0 ; tt < nperm ; tt++) {\r\n if( Tsabs(k) <= T0stmp(tt) ) {\r\n tmp3++;\r\n }\r\n \r\n P0s(tt) = (double) rankarma(tt) / (double) nperm;\r\n }\r\n \r\n if(k == 0) {\r\n minp0 = P0s;\r\n } else {\r\n for( int ii = 0; ii < nperm; ii++) {\r\n if( minp0(ii) > P0s(ii) ) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n double tmp_pvalue = (double) tmp3 / (double) nperm;\r\n pPerm0(k) = tmp_pvalue;\r\n \r\n if (tmp_pvalue <= minP_tmp) {\r\n minP_tmp = tmp_pvalue;\r\n }\r\n \r\n }\r\n \r\n int count_pvalue = 0;\r\n for(int j=0; j < nperm; j++) {\r\n if( minP_tmp >= minp0(j) ) {\r\n count_pvalue = count_pvalue + 1;\r\n }\r\n }\r\n \r\n pPerm0(n_pow) = (double) (count_pvalue + 1) / (double) (nperm + 1);\r\n\r\n \r\n return pPerm0;\r\n}\r\n\r\n\r\n// [[Rcpp::export]]\r\nvoid set_seed(unsigned int seed) {\r\n Rcpp::Environment base_env(\"package:base\");\r\n Rcpp::Function set_seed_r = base_env[\"set.seed\"];\r\n set_seed_r(seed);\r\n}\r\n\r\n// This function is taken from http://stackoverflow.com/questions/39153082/rcpp-rank-function-that-does-average-ties\r\nclass Comparator {\r\n private:\r\n const Rcpp::NumericVector& ref;\r\n \r\n bool is_na(double x) const\r\n {\r\n return Rcpp::traits::is_na(x);\r\n }\r\n \r\n public:\r\n Comparator(const Rcpp::NumericVector& ref_)\r\n : ref(ref_)\r\n {}\r\n \r\n bool operator()(const int ilhs, const int irhs) const\r\n {\r\n double lhs = ref[ilhs], rhs = ref[irhs];\r\n if (is_na(lhs)) return false;\r\n if (is_na(rhs)) return true;\r\n return lhs < rhs;\r\n }\r\n};\r\n\r\n\r\n// [[Rcpp::export]]\r\nRcpp::NumericVector avg_rank2(Rcpp::NumericVector x)\r\n{\r\n R_xlen_t sz = x.size();\r\n Rcpp::IntegerVector w = Rcpp::seq(0, sz - 1);\r\n std::sort(w.begin(), w.end(), Comparator(x));\r\n \r\n Rcpp::NumericVector r = Rcpp::no_init_vector(sz);\r\n for (R_xlen_t n, i = 0; i < sz; i += n) {\r\n n = 1;\r\n while (i + n < sz && x[w[i]] == x[w[i + n]]) ++n;\r\n for (R_xlen_t k = 0; k < n; k++) {\r\n r[w[i + k]] = i + (n + 1) / 2.;\r\n }\r\n }\r\n \r\n return r;\r\n}\r\n\r\n\r\n// [[Rcpp::depends(RcppArmadillo)]]\r\n// [[Rcpp::export]]\r\nRcpp::List aSPUsPathEngine2(Rcpp::List CH, Rcpp::List CHcovSq, arma::vec pow1, arma::vec pow2, int nGenes, int n_perm, int k, arma::vec nSNPs0, arma::vec nChrom0, arma::vec Ts2, int s) {\r\n const int n_ch = CH.size();\r\n const int n_pow1 = pow1.size();\r\n const int n_pow2 = pow2.size();\r\n \r\n arma::vec T0s(n_perm);\r\n arma::vec T0st(nGenes*n_pow1);\r\n arma::vec Ts2t(n_pow1*n_pow2);\r\n arma::vec pPerm0(n_pow1*n_pow2);\r\n arma::vec minp0(n_perm);\r\n arma::vec P0s(n_perm);\r\n \r\n // iterate for pow2\r\n for(int j2=0 ; j2 < n_pow2; j2++) {\r\n // iterate for pow1\r\n for(int j=0 ; j < n_pow1; j++) {\r\n \r\n // set seed to use same random numbers for same b's\r\n // This is necessary to use efficient memory\r\n set_seed(s);\r\n for(int b=0; b < n_perm; b++) {\r\n \r\n // Generate Score from null distribution\r\n Rcpp::NumericVector U00 = rnorm(k,0,1);\r\n arma::vec u0 = as(U00);\r\n arma::vec U0(1);\r\n \r\n int SNPstart = 0;\r\n // iterate for chromosome\r\n for(int b2 = 0; b2 < n_ch ; b2++) {\r\n \r\n \r\n // itreate for chromosome\r\n if( b2 != 0) {\r\n SNPstart = sum( nChrom0.subvec(0,b2-1) ) ;\r\n }\r\n int idx1 = SNPstart;\r\n int idx2 = SNPstart+nChrom0(b2)-1;\r\n \r\n arma::vec TT = as(CHcovSq[b2])*u0.subvec(idx1, idx2) ;\r\n U0 = join_cols(U0,TT) ;\r\n }\r\n \r\n arma::vec UU2 = U0.subvec(1,U0.size()-1);\r\n \r\n \r\n // iterate for genes\r\n SNPstart = 0;\r\n for(int iGene = 0 ; iGene < nGenes ; iGene++ ) {\r\n \r\n // calculate starting and ending position of each gene from nSNPs0 vector\r\n if( iGene != 0) {\r\n SNPstart = sum( nSNPs0.subvec(0,iGene-1) ) ;\r\n }\r\n int idx1 = SNPstart;\r\n int idx2 = SNPstart+nSNPs0(iGene)-1;\r\n \r\n // calculate 1st level test statistic\r\n if( pow1[j] > 0) {\r\n arma::vec tmp1 = pow(UU2.subvec(idx1, idx2),pow1[j]);\r\n double tmp2 = sum(tmp1);\r\n \r\n if( tmp2 > 0 ) {\r\n T0st(j*nGenes+iGene) = pow(std::abs(tmp2)/nSNPs0[iGene] , 1/pow1[j]);\r\n } else {\r\n T0st(j*nGenes+iGene) = -pow(std::abs(tmp2)/nSNPs0[iGene] , 1/pow1[j]);\r\n }\r\n \r\n } else {\r\n arma::vec T0tp = abs(UU2.subvec(idx1, idx2));\r\n T0st(j*nGenes+iGene) = max(abs(T0tp));\r\n }\r\n }\r\n \r\n // calculate 2nd level test statistics\r\n if( pow2[j2] > 0) {\r\n arma::vec tmp3 = pow(T0st.subvec(j*nGenes,(j+1)*nGenes-1), pow2[j2]);\r\n double tmp4 = sum(tmp3);\r\n T0s(b) = tmp4;\r\n } else {\r\n T0s(b) = max( arma::abs(T0st.subvec(j*nGenes,(j+1)*nGenes-1)) ) ;\r\n }\r\n }\r\n \r\n \r\n // Calculate P-values\r\n int tmp3 = 0;\r\n arma::vec T0sabs = arma::abs(T0s);\r\n Rcpp::NumericVector a( T0sabs.begin(), T0sabs.end() );\r\n Rcpp::NumericVector ranka = avg_rank2(a);\r\n arma::vec rankarma = as(ranka);\r\n \r\n for( int tt=0 ; tt < n_perm ; tt++) {\r\n if( std::abs(Ts2(j2*n_pow1 + j) ) <= std::abs(T0s(tt))) {\r\n tmp3++;\r\n }\r\n \r\n P0s(tt) = (double) (n_perm - rankarma(tt) + 1) / (double) n_perm;\r\n }\r\n \r\n minp0 = P0s;\r\n \r\n if(j == 1) {\r\n for( int ii=0; ii < n_perm; ii++) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n } else {\r\n for( int ii=0; ii < n_perm; ii++) {\r\n if( minp0(ii) > P0s(ii) ) {\r\n minp0(ii) = P0s(ii);\r\n }\r\n }\r\n }\r\n \r\n pPerm0(j2*n_pow1 + j) = (double) tmp3 / (double) n_perm;\r\n \r\n }\r\n }\r\n return Rcpp::List::create(Rcpp::Named(\"minp0\") = minp0,\r\n Rcpp::Named(\"pPerm0\") = pPerm0,\r\n Rcpp::Named(\"P0s\") = P0s);\r\n}\r\n", "meta": {"hexsha": "362a4a30b28c98344a761fe75f6880cd664d17cf", "size": 34699, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/GMaSPU_support.cpp", "max_stars_repo_name": "blackcavalry/iwas2", "max_stars_repo_head_hexsha": "5742045ae832a8e17ac997faab8b3b6978fecabd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/GMaSPU_support.cpp", "max_issues_repo_name": "blackcavalry/iwas2", "max_issues_repo_head_hexsha": "5742045ae832a8e17ac997faab8b3b6978fecabd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/GMaSPU_support.cpp", "max_forks_repo_name": "blackcavalry/iwas2", "max_forks_repo_head_hexsha": "5742045ae832a8e17ac997faab8b3b6978fecabd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.625772286, "max_line_length": 187, "alphanum_fraction": 0.4432116199, "num_tokens": 10569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6791786861878392, "lm_q2_score": 0.4416730056646256, "lm_q1q2_score": 0.2999748917119345}} {"text": "\n/******************************************************************************\n\n Markov random field model for regular 2D lattice.\n\n Copyright (c) 2009 - 2012\n Alexander Rukletsov \n All rights reserved.\n\n Redistribution and use in source and binary forms, with or without\n modification, are permitted provided that the following conditions\n are met:\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS \"AS IS\" AND\n ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n SUCH DAMAGE.\n\n*******************************************************************************/\n\n#ifndef MRF_2D_HPP_1140ED81_1E3E_4AEB_AFBB_6CA70FE3EF9B_\n#define MRF_2D_HPP_1140ED81_1E3E_4AEB_AFBB_6CA70FE3EF9B_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"bo/core/raw_image_2d.hpp\"\n\nnamespace bo {\nnamespace mrf {\n\n// A class representing a Markov random field on a regular 2D lattice. Operates on\n// random field configuration using given observation and clique functions. Only first\n// order (pairwise) neighbourhood is supproted. No copies of an instance are allowed.\ntemplate \nclass MRF2D: public boost::noncopyable\n{\npublic:\n typedef NodeType& reference;\n typedef const NodeType& const_reference;\n\n typedef RawImage2D RandomLattice;\n typedef RawImage2D DataLattice;\n typedef boost::function LikelihoodEnergy;\n typedef boost::function PriorEnergy;\n\n MRF2D(const RandomLattice& initial_configuration, const DataLattice& observation,\n LikelihoodEnergy likelihood, PriorEnergy prior);\n\n RealType compute_full_energy() const;\n RealType compute_local_energy(NodeType val, std::size_t col, std::size_t row) const;\n RealType compute_local_likelihood(NodeType val, std::size_t col, std::size_t row) const;\n\n const_reference operator()(std::size_t col, std::size_t row) const;\n reference operator()(std::size_t col, std::size_t row);\n\n std::size_t width() const;\n std::size_t height() const;\n\nprivate:\n RealType right_clique_(NodeType val, std::size_t col, std::size_t row) const;\n RealType down_clique_(NodeType val, std::size_t col, std::size_t row) const;\n RealType left_clique_(NodeType val, std::size_t col, std::size_t row) const;\n RealType up_clique_(NodeType val, std::size_t col, std::size_t row) const;\n\n RealType prior_fun_(NodeType val, std::size_t neigh_col, std::size_t neigh_row) const;\n RealType likelihood_fun_(NodeType val, std::size_t col, std::size_t row) const;\n\nprivate:\n RandomLattice configuration_;\n DataLattice observation_;\n LikelihoodEnergy likelihood_;\n PriorEnergy prior_;\n};\n\n\ntemplate \nMRF2D::MRF2D(const RandomLattice& initial_configuration,\n const DataLattice& observation, LikelihoodEnergy likelihood, PriorEnergy prior):\n configuration_(initial_configuration),\n observation_(observation),\n likelihood_(likelihood),\n prior_(prior)\n{\n // Check if the dimensions of observation and configuration are the same.\n if ((configuration_.width() != observation_.width()) ||\n (configuration_.height() != configuration_.height()))\n {\n BOOST_ASSERT(false && \"Dimensions of the configuration and observation do not coincide.\");\n throw std::logic_error(\"MRF2D: dimensions of the random field lattice and the \"\n \"observation data must be the same.\");\n }\n}\n\n// Computes full energy of the current MRF state. It takes sum over all zero order\n// (single node) and first order (every two adjacent nodes) cliques using corresponding\n// clique functions. In order to iterate over all first order cliques, for every\n// node we can consider only right and down neighbour except for some border nodes.\ntemplate \nRealType MRF2D::compute_full_energy() const\n{\n RealType energy(0);\n\n for (std::size_t col = 0; col < configuration_.width(); ++col) {\n for (std::size_t row = 0; row < configuration_.height(); ++row) {\n NodeType value = configuration_(col, row);\n energy += (likelihood_fun_(value, col, row) +\n right_clique_(value, col, row) +\n down_clique_(value, col, row));\n } }\n\n return energy;\n}\n\n// Computes a local energy of the neighbourhood of the given node with provided value.\n// Border checks are done inside corresponding clique functions.\ntemplate \nRealType MRF2D::compute_local_energy(NodeType val,\n std::size_t col, std::size_t row) const\n{\n // Compute likelihood energy for the given value at the given position.\n RealType energy = likelihood_fun_(val, col, row);\n\n // Compute prior energy of the given node given its neighbours.\n energy += (right_clique_(val, col, row) + down_clique_(val, col, row) +\n left_clique_(val, col, row) + up_clique_(val, col, row));\n\n return energy;\n}\n\n// Computes a likelihood function for the given node with provided value.\ntemplate \nRealType MRF2D::compute_local_likelihood(NodeType val,\n std::size_t col, std::size_t row) const\n{\n return\n likelihood_fun_(val, col, row);\n}\n\ntemplate inline\ntypename MRF2D::const_reference\nMRF2D::operator()(std::size_t col, std::size_t row) const\n{\n return configuration_(col, row);\n}\n\ntemplate inline\ntypename MRF2D::reference\nMRF2D::operator()(std::size_t col, std::size_t row)\n{\n return configuration_(col, row);\n}\n\ntemplate inline\nstd::size_t MRF2D::width() const\n{\n return configuration_.width();\n}\n\ntemplate inline\nstd::size_t MRF2D::height() const\n{\n return configuration_.height();\n}\n\n\n// Next four functions represent cliques and neighbourhood relations in the model.\n// They check for border overrun and call the associated clique function.\ntemplate inline\nRealType MRF2D::right_clique_(NodeType val,\n std::size_t col, std::size_t row) const\n{\n return\n (col < configuration_.width() - 1) ? prior_fun_(val, col + 1, row) : RealType(0);\n}\n\ntemplate inline\nRealType MRF2D::down_clique_(NodeType val,\n std::size_t col, std::size_t row) const\n{\n return\n (row < configuration_.height() - 1) ? prior_fun_(val, col, row + 1) : RealType(0);\n}\n\ntemplate inline\nRealType MRF2D::left_clique_(NodeType val,\n std::size_t col, std::size_t row) const\n{\n return\n (col > 0) ? prior_fun_(val, col - 1, row) : RealType(0);\n}\n\ntemplate inline\nRealType MRF2D::up_clique_(NodeType val,\n std::size_t col, std::size_t row) const\n{\n return\n (row > 0) ? prior_fun_(val, col, row - 1) : RealType(0);\n}\n\n// Computes prior energy for two nodes.\ntemplate inline\nRealType MRF2D::prior_fun_(NodeType val,\n std::size_t neigh_col, std::size_t neigh_row) const\n{\n return prior_(val, configuration_(neigh_col, neigh_row));\n}\n\n// Computes likelihood energy for the given node.\ntemplate inline\nRealType MRF2D::likelihood_fun_(NodeType val,\n std::size_t col, std::size_t row) const\n{\n return likelihood_(observation_(col, row), val);\n}\n\n} // namespace mrf\n} // namespace bo\n\n#endif // MRF_2D_HPP_1140ED81_1E3E_4AEB_AFBB_6CA70FE3EF9B_\n", "meta": {"hexsha": "ae9ea304b5aeab5e5c981034cd253041aba03311", "size": 9508, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Bo/mrf/mrf_2d.hpp", "max_stars_repo_name": "rukletsov/bo", "max_stars_repo_head_hexsha": "bfece9e8f910b0c8f522733854405bf0a801b0e8", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2016-09-14T03:30:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T10:53:32.000Z", "max_issues_repo_path": "Bo/mrf/mrf_2d.hpp", "max_issues_repo_name": "rukletsov/bo", "max_issues_repo_head_hexsha": "bfece9e8f910b0c8f522733854405bf0a801b0e8", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Bo/mrf/mrf_2d.hpp", "max_forks_repo_name": "rukletsov/bo", "max_forks_repo_head_hexsha": "bfece9e8f910b0c8f522733854405bf0a801b0e8", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.9495798319, "max_line_length": 98, "alphanum_fraction": 0.7297013042, "num_tokens": 2286, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804196836383, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.29972491183530847}} {"text": "#ifndef EDGE_PLANE_PARALLEL_HPP\n#define EDGE_PLANE_PARALLEL_HPP\n\n#include \n#include \n#include \n\nnamespace g2o {\n\nclass EdgePlaneParallel : public BaseBinaryEdge<3, Eigen::Vector3d, VertexPlane, VertexPlane> {\npublic:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n EdgePlaneParallel() : BaseBinaryEdge<3, Eigen::Vector3d, VertexPlane, VertexPlane>() {\n _information.setIdentity();\n _error.setZero();\n }\n\n void computeError() override {\n const VertexPlane* v1 = static_cast(_vertices[0]);\n const VertexPlane* v2 = static_cast(_vertices[1]);\n\n Eigen::Vector3d normal1 = v1->estimate().normal();\n Eigen::Vector3d normal2 = v2->estimate().normal();\n\n if (normal1.dot(normal2) < 0.0) {\n normal2 = -normal2;\n }\n\n _error = (normal2 - normal1) - _measurement;\n }\n virtual bool read(std::istream& is) override {\n Eigen::Vector3d v;\n for (int i = 0; i < 3; ++i) {\n is >> v[i];\n }\n\n setMeasurement(v);\n for(int i = 0; i < information().rows(); ++i) {\n for(int j = i; j < information().cols(); ++j) {\n is >> information()(i, j);\n if(i != j) {\n information()(j, i) = information()(i, j);\n }\n }\n }\n\n return true;\n }\n\n virtual bool write(std::ostream& os) const override {\n for(int i = 0; i < 3; ++i) {\n os << _measurement[i] << \" \";\n }\n\n for(int i = 0; i < information().rows(); ++i) {\n for(int j = i; j < information().cols(); ++j) {\n os << \" \" << information()(i, j);\n };\n }\n return os.good();\n }\n\n virtual void setMeasurement(const Eigen::Vector3d& m) override { _measurement = m; }\n\n virtual int measurementDimension() const override { return 3; }\n};\n\nclass EdgePlanePerpendicular : public BaseBinaryEdge<1, Eigen::Vector3d, VertexPlane, VertexPlane> {\npublic:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n EdgePlanePerpendicular() : BaseBinaryEdge<1, Eigen::Vector3d, VertexPlane, VertexPlane>() {\n _information.setIdentity();\n _error.setZero();\n }\n\n void computeError() override {\n const VertexPlane* v1 = static_cast(_vertices[0]);\n const VertexPlane* v2 = static_cast(_vertices[1]);\n\n Eigen::Vector3d normal1 = v1->estimate().normal().normalized();\n Eigen::Vector3d normal2 = v2->estimate().normal().normalized();\n\n _error[0] = normal1.dot(normal2);\n }\n virtual bool read(std::istream& is) override {\n Eigen::Vector3d v;\n for (int i = 0; i < 3; ++i) {\n is >> v[i];\n }\n\n setMeasurement(v);\n for(int i = 0; i < information().rows(); ++i) {\n for(int j = i; j < information().cols(); ++j) {\n is >> information()(i, j);\n if (i != j) {\n information()(j, i) = information()(i, j);\n }\n }\n }\n\n return true;\n }\n\n virtual bool write(std::ostream& os) const override {\n for (int i = 0; i < 3; ++i) {\n os << _measurement[i] << \" \";\n }\n\n for(int i = 0; i < information().rows(); ++i) {\n for(int j = i; j < information().cols(); ++j) {\n os << \" \" << information()(i, j);\n };\n }\n return os.good();\n }\n\n virtual void setMeasurement(const Eigen::Vector3d& m) override { _measurement = m; }\n\n virtual int measurementDimension() const override { return 3; }\n};\n\n} // namespace g2o\n\n#endif // EDGE_PLANE_PARALLEL_HPP\n", "meta": {"hexsha": "014fc829e07fddcba3954d5864de0d3038fd2c13", "size": 3409, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/g2o/edge_plane_parallel.hpp", "max_stars_repo_name": "hyunbeen99/kuuve_slam", "max_stars_repo_head_hexsha": "afc7861ba69d656f08c4df73ed15f7721004ba87", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-02-04T01:44:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T01:44:31.000Z", "max_issues_repo_path": "include/g2o/edge_plane_parallel.hpp", "max_issues_repo_name": "hyunbeen99/kuuve_slam", "max_issues_repo_head_hexsha": "afc7861ba69d656f08c4df73ed15f7721004ba87", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/g2o/edge_plane_parallel.hpp", "max_forks_repo_name": "hyunbeen99/kuuve_slam", "max_forks_repo_head_hexsha": "afc7861ba69d656f08c4df73ed15f7721004ba87", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-02-04T01:44:33.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-04T01:44:33.000Z", "avg_line_length": 27.272, "max_line_length": 100, "alphanum_fraction": 0.6025227339, "num_tokens": 975, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804196836383, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.29972491183530847}} {"text": "// Copyright (C) 2008-today The SG++ project\n// This file is part of the SG++ project. For conditions of distribution and\n// use, please see the copyright notice provided with SG++ or at\n// sgpp.sparsegrids.org\n\n/**\n * \\page example_optimization_cpp optimization.cpp\n *\n * On this page, we look at an example application of the sgpp::optimization module.\n * Versions of the example are given in all languages\n * currently supported by SG++: C++, Python, Java, and MATLAB.\n *\n * The example interpolates a bivariate test function with B-splines instead\n * of piecewise linear basis functions to obtain a smoother interpolant.\n * The resulting sparse grid function is then minimized with the method of steepest descent.\n * For comparison, we also minimize the objective function with Nelder-Mead's method.\n */\n\n/**\n * First, we include all the necessary headers, including those of the sgpp::base and\n * sgpp::optimization module.\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nusing sgpp::base::DataMatrix;\nusing sgpp::base::DataVector;\nusing sgpp::base::Grid;\nusing sgpp::base::GridGenerator;\nusing sgpp::base::GridStorage;\nusing boost::property_tree::ptree;\n\n/**\n * The function \\f$f\\colon [0, 1]^d \\to \\mathbb{R}\\f$ to be minimized\n * is called objective function and has to derive from\n * sgpp::optimization::ScalarFunction.\n * In the constructor, we give the dimensionality of the domain\n * (in this case \\f$d = 2\\f$).\n * The eval method evaluates the objective function and returns the function\n * value \\f$f(\\vec{x})\\f$ for a given point \\f$\\vec{x} \\in [0, 1]^d\\f$.\n * The clone method returns a std::unique_ptr to a clone of the object\n * and is used for parallelization (in case eval is not thread-safe).\n */\nclass ExampleFunction : public sgpp::optimization::ScalarFunction {\n public:\n sgpp::base::DataVector featureVector;\n sgpp::datadriven::LearnerSGDE& learner;\n \n // our optimization problem is 3dim\n ExampleFunction(sgpp::datadriven::LearnerSGDE& _learner) : sgpp::optimization::ScalarFunction(3), learner(_learner) {}\n\n // x is 3dim, we need to supply the rest (feature vector)\n double eval(const sgpp::base::DataVector& x) {\n\n sgpp::base::DataVector xNew(x);\n\n //xNew.append(featureVector.get(0));\n //xNew.append(featureVector.get(1));\n //xNew.append(featureVector.get(2));\n //xNew.append(featureVector.get(3));\n\n xNew.append(featureVector.get(0));\n xNew.append(featureVector.get(1));\n xNew.append(featureVector.get(2));\n xNew.append(featureVector.get(3));\n\n return learner.pdf(xNew);\n }\n\n virtual void clone(std::unique_ptr& clone) const {\n clone = std::unique_ptr(new ExampleFunction(*this));\n }\n\n void setParamters(const sgpp::base::DataVector& reqFeatureVector){\n featureVector=reqFeatureVector;\n }\n};\n\n/**\n * Now, we can start with the \\c main function.\n */\nvoid printLine() {\n std::cout << \"----------------------------------------\"\n \"----------------------------------------\\n\";\n}\n\nint main(int argc, const char* argv[]) {\n (void)argc;\n (void)argv;\n\n double featureVectorCoeff_0 = atof(argv[3]);\n double featureVectorCoeff_1 = atof(argv[4]);\n double featureVectorCoeff_2 = atof(argv[5]);\n double featureVectorCoeff_3 = atof(argv[6]);\n\n std::string filename = \"../\" + std::string(argv[1]);\n std::string ininame = \"../\" + std::string(argv[2]);\n\n std::cout << \"# loading file: \" << filename << std::endl;\n sgpp::datadriven::Dataset dataset =\n sgpp::datadriven::ARFFTools::readARFFFromFile(filename);\n sgpp::base::DataMatrix& samples = dataset.getData();\n\n /**\n * Configure the sparse grid of level 3 with linear basis functions and the same dimension as the\n * given test data.\n * Alternatively load a sparse grid that has been saved to a file, see the commented line.\n */\n std::cout << \"# create grid config\" << std::endl;\n sgpp::base::RegularGridConfiguration gridConfig;\n gridConfig.dim_ = dataset.getDimension();\n gridConfig.level_ = 3;\n gridConfig.type_ = sgpp::base::GridType::Linear; //TODO: BSplines not available, but does not matter\n // gridConfig.filename_ = \"/tmp/sgde-grid-4391dc6e-54cd-4ca2-9510-a9c02a2889ec.grid\";\n\n /**\n * Configure the adaptive refinement. Therefore the number of refinements and the number of points\n * are specified.\n */\n std::cout << \"# create adaptive refinement config\" << std::endl;\n sgpp::base::AdaptivityConfiguration adaptConfig;\n adaptConfig.numRefinements_ = 0;\n adaptConfig.noPoints_ = 10;\n\n /**\n * Configure the solver. The solver type is set to the conjugent gradient method and the maximum\n * number of iterations, the tolerance epsilon and the threshold are specified.\n */\n std::cout << \"# create solver config\" << std::endl;\n sgpp::solver::SLESolverConfiguration solverConfig;\n solverConfig.type_ = sgpp::solver::SLESolverType::CG;\n solverConfig.maxIterations_ = 1000;\n solverConfig.eps_ = 1e-14;\n solverConfig.threshold_ = 1e-14;\n\n /**\n * Configure the regularization for the laplacian operator.\n */\n std::cout << \"# create regularization config\" << std::endl;\n sgpp::datadriven::RegularizationConfiguration regularizationConfig;\n regularizationConfig.type_ = sgpp::datadriven::RegularizationType::Laplace;\n\n /**\n * Configure the learner by specifying:\n * - an initial value for the lagrangian multiplier \\f$\\lambda\\f$ and the interval\n * \\f$ [\\lambda_{Start} , \\lambda_{End}] \\f$ in which \\f$\\lambda\\f$ will be searched,\n * - whether a logarithmic scale is used,\n * - the parameters shuffle and an initial seed for the random value generation,\n * - whether parts of the output shall be kept off.\n */\n std::cout << \"# create learner config\" << std::endl;\n sgpp::datadriven::CrossvalidationConfiguration crossvalidationConfig;\n crossvalidationConfig.enable_ = false;\n crossvalidationConfig.kfold_ = 3;\n crossvalidationConfig.lambda_ = 3.16228e-06;\n crossvalidationConfig.lambdaStart_ = 1e-1;\n crossvalidationConfig.lambdaEnd_ = 1e-10;\n crossvalidationConfig.lambdaSteps_ = 3;\n crossvalidationConfig.logScale_ = true;\n crossvalidationConfig.shuffle_ = true;\n crossvalidationConfig.seed_ = 1234567;\n crossvalidationConfig.silent_ = false;\n\n /**\n * Create the learner using the configuratons set above. Then initialize it with the data read\n * from the file in the first step and train the learner.\n */\n std::cout << \"# creating the learner\" << std::endl;\n sgpp::datadriven::LearnerSGDE learner(gridConfig, adaptConfig, solverConfig, regularizationConfig,\n crossvalidationConfig);\n learner.initialize(samples);\n learner.train();\n /**\n * Estimate the probability density function (pdf) via a gaussian kernel density estimation (KDE)\n * and print the corresponding values.\n */\n sgpp::datadriven::KernelDensityEstimator kde(samples);\n sgpp::base::DataVector x(learner.getDim());\n // samples.getRow(samples.getNrows()/2, x);\n samples.getRow(1, x);\n \n std::cout << \"--------------------------------------------------------\\n\";\n std::cout << \"x= \" << x.toString() << \"\\n\";\n std::cout << \"SGDE dimensions \" << learner.getDim() << \"\\n\";\n std::cout << \"SGDE sample count \" << learner.getNsamples() << \"\\n\";\n std::cout << learner.getSurpluses()->getSize() << \" -> \" << learner.getSurpluses()->sum() << \"\\n\";\n std::cout << \"pdf_SGDE(x) = \" << learner.pdf(x) << \" ~ \" << kde.pdf(x) << \" =pdf_KDE(x)\\n\";\n std::cout << \"mean_SGDE(x) = \" << learner.mean() << \" ~ \" << kde.mean() << \" = mean_KDE(x)\\n\";\n std::cout << \"var_SGDE(x) = \" << learner.variance() << \" ~ \" << kde.variance() << \"=var_KDE(x)\\n\";\n\n std::cout << \"sgpp::optimization example program started.\\n\\n\";\n // increase verbosity of the output\n sgpp::optimization::Printer::getInstance().setVerbosity(2);\n\n /**\n * Here, we define some parameters: objective function, dimensionality,\n * B-spline degree, maximal number of grid points, and adaptivity.\n */\n // objective function\n ExampleFunction f(learner);\n sgpp::base::DataVector testFV;\n testFV.append(featureVectorCoeff_0);\n testFV.append(featureVectorCoeff_1);\n testFV.append(featureVectorCoeff_2);\n testFV.append(featureVectorCoeff_3);\n\n f.setParamters(testFV);\n // dimension of domain\n const size_t d = f.getNumberOfParameters();\n // B-spline degree\n const size_t p = 3;\n // maximal number of grid points\n const size_t N = 30;\n // adaptivity of grid generation\n const double gamma = 0.95;\n\n /**\n * First, we define a grid with modified B-spline basis functions and\n * an iterative grid generator, which can generate the grid adaptively.\n */\n sgpp::base::ModBsplineGrid grid(d, p);\n sgpp::optimization::IterativeGridGeneratorRitterNovak gridGen(f, grid, N, gamma);\n\n /**\n * With the iterative grid generator, we generate adaptively a sparse grid.\n */\n printLine();\n std::cout << \"Generating grid...\\n\\n\";\n\n if (!gridGen.generate()) {\n std::cout << \"Grid generation failed, exiting.\\n\";\n return 1;\n }\n\n /**\n * Then, we hierarchize the function values to get hierarchical B-spline\n * coefficients of the B-spline sparse grid interpolant\n * \\f$\\tilde{f}\\colon [0, 1]^d \\to \\mathbb{R}\\f$.\n */\n printLine();\n std::cout << \"Hierarchizing...\\n\\n\";\n sgpp::base::DataVector functionValues(gridGen.getFunctionValues());\n sgpp::base::DataVector coeffs(functionValues.getSize());\n sgpp::optimization::HierarchisationSLE hierSLE(grid);\n sgpp::optimization::sle_solver::Auto sleSolver;\n\n // solve linear system\n if (!sleSolver.solve(hierSLE, functionValues, coeffs)) {\n std::cout << \"Solving failed, exiting.\\n\";\n return 1;\n }\n\n /**\n * We define the interpolant \\f$\\tilde{f}\\f$ and its gradient\n * \\f$\\nabla\\tilde{f}\\f$ for use with the gradient method (steepest descent).\n * Of course, one can also use other optimization algorithms from\n * sgpp::optimization::optimizer.\n */\n printLine();\n std::cout << \"Optimizing smooth interpolant...\\n\\n\";\n sgpp::optimization::InterpolantScalarFunction ft(grid, coeffs);\n sgpp::optimization::InterpolantScalarFunctionGradient ftGradient(grid, coeffs);\n sgpp::optimization::optimizer::GradientDescent gradientDescent(ft, ftGradient);\n sgpp::base::DataVector x0(d);\n double fX0;\n double ftX0;\n\n /**\n * The gradient method needs a starting point.\n * We use a point of our adaptively generated sparse grid as starting point.\n * More specifically, we use the point with the smallest\n * (most promising) function value and save it in x0.\n */\n {\n sgpp::base::GridStorage& gridStorage = grid.getStorage();\n\n // index of grid point with minimal function value\n size_t x0Index =\n std::distance(functionValues.getPointer(),\n std::min_element(functionValues.getPointer(),\n functionValues.getPointer() + functionValues.getSize()));\n\n //x0 = gridStorage.getCoordinates(gridStorage[x0Index]);\n\n x0.set(0, samples.get(0,0)/2);\n x0.set(1, samples.get(0,1));\n x0.set(2, samples.get(0,2));\n\n\n fX0 = functionValues[x0Index];\n ftX0 = ft.eval(x0);\n }\n\n std::cout << \"Gradient starting point:\\n\";\n std::cout << \"x0 = \" << x0.toString() << \"\\n\";\n std::cout << \"f(x0) = \" << fX0 << \", ft(x0) = \" << ftX0 << \"\\n\\n\";\n\n /**\n * We apply the gradient method and print the results.\n */\n gradientDescent.setStartingPoint(x0);\n gradientDescent.optimize();\n const sgpp::base::DataVector& xOpt = gradientDescent.getOptimalPoint();\n const double ftXOpt = gradientDescent.getOptimalValue();\n const double fXOpt = f.eval(xOpt);\n\n std::cout << \"\\noptimal control point:\\n\";\n std::cout << \"for feature vector\" << testFV.toString() << \"\\n\";\n std::cout << \"xOpt = \" << xOpt.toString() << \"\\n\";\n std::cout << \"f(xOpt) = \" << fXOpt << \", ft(xOpt) = \" << ftXOpt << \"\\n\\n\";\n \n /**\n * We modify the control point inside the .ini file\n */\n\n ptree pt;\n\n boost::property_tree::ini_parser::read_ini( ininame, pt );\n\n pt.put(\"Simulation.cpX\", xOpt.get(0));\n pt.put(\"Simulation.cpY\", xOpt.get(1));\n pt.put(\"Simulation.cpZ\", xOpt.get(2));\n\n boost::property_tree::write_ini( ininame, pt );\n\n return 0;\n}", "meta": {"hexsha": "8ec768fcdfa2296cc5e5b9010dcc4adae1701f1a", "size": 12823, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "students/cpp/optimize.cpp", "max_stars_repo_name": "maierbn/peg-in-hole", "max_stars_repo_head_hexsha": "9c8075e2bb479b605af9fd73e22b5f6d74a3807b", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-03-18T00:15:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T00:15:03.000Z", "max_issues_repo_path": "students/cpp/optimize.cpp", "max_issues_repo_name": "maierbn/peg-in-hole", "max_issues_repo_head_hexsha": "9c8075e2bb479b605af9fd73e22b5f6d74a3807b", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "students/cpp/optimize.cpp", "max_forks_repo_name": "maierbn/peg-in-hole", "max_forks_repo_head_hexsha": "9c8075e2bb479b605af9fd73e22b5f6d74a3807b", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.3848396501, "max_line_length": 120, "alphanum_fraction": 0.6818217266, "num_tokens": 3442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259584, "lm_q2_score": 0.49609382947091946, "lm_q1q2_score": 0.29960685613250526}} {"text": "// (C) Copyright John Maddock 2006.\n// Use, modification and distribution are subject to the\n// Boost Software License, Version 1.0. (See accompanying file\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n\n//\n// This is not a complete header file, it is included by beta.hpp\n// after it has defined it's definitions. This inverts the incomplete\n// beta functions ibeta and ibetac on the first parameters \"a\"\n// and \"b\" using a generic root finding algorithm (TOMS Algorithm 748).\n//\n\n#ifndef BOOST_MATH_SP_DETAIL_BETA_INV_AB\n#define BOOST_MATH_SP_DETAIL_BETA_INV_AB\n\n#ifdef _MSC_VER\n#pragma once\n#endif\n\n#include \n#include \n\nnamespace boost{ namespace math{ namespace detail{\n\ntemplate \nstruct beta_inv_ab_t\n{\n beta_inv_ab_t(T b_, T z_, T p_, bool invert_, bool swap_ab_) : b(b_), z(z_), p(p_), invert(invert_), swap_ab(swap_ab_) {}\n T operator()(T a)\n {\n return invert ? \n p - boost::math::ibetac(swap_ab ? b : a, swap_ab ? a : b, z, Policy()) \n : boost::math::ibeta(swap_ab ? b : a, swap_ab ? a : b, z, Policy()) - p;\n }\nprivate:\n T b, z, p;\n bool invert, swap_ab;\n};\n\ntemplate \nT inverse_negative_binomial_cornish_fisher(T n, T sf, T sfc, T p, T q, const Policy& pol)\n{\n BOOST_MATH_STD_USING\n // mean:\n T m = n * (sfc) / sf;\n T t = sqrt(n * (sfc));\n // standard deviation:\n T sigma = t / sf;\n // skewness\n T sk = (1 + sfc) / t;\n // kurtosis:\n T k = (6 - sf * (5+sfc)) / (n * (sfc));\n // Get the inverse of a std normal distribution:\n T x = boost::math::erfc_inv(p > q ? 2 * q : 2 * p, pol) * constants::root_two();\n // Set the sign:\n if(p < 0.5)\n x = -x;\n T x2 = x * x;\n // w is correction term due to skewness\n T w = x + sk * (x2 - 1) / 6;\n //\n // Add on correction due to kurtosis.\n //\n if(n >= 10)\n w += k * x * (x2 - 3) / 24 + sk * sk * x * (2 * x2 - 5) / -36;\n\n w = m + sigma * w;\n if(w < tools::min_value())\n return tools::min_value();\n return w;\n}\n\ntemplate \nT ibeta_inv_ab_imp(const T& b, const T& z, const T& p, const T& q, bool swap_ab, const Policy& pol)\n{\n BOOST_MATH_STD_USING // for ADL of std lib math functions\n //\n // Special cases first:\n //\n BOOST_MATH_INSTRUMENT_CODE(\"b = \" << b << \" z = \" << z << \" p = \" << p << \" q = \" << \" swap = \" << swap_ab);\n if(p == 0)\n {\n return swap_ab ? tools::min_value() : tools::max_value();\n }\n if(q == 0)\n {\n return swap_ab ? tools::max_value() : tools::min_value();\n }\n //\n // Function object, this is the functor whose root\n // we have to solve:\n //\n beta_inv_ab_t f(b, z, (p < q) ? p : q, (p < q) ? false : true, swap_ab);\n //\n // Tolerance: full precision.\n //\n tools::eps_tolerance tol(policies::digits());\n //\n // Now figure out a starting guess for what a may be, \n // we'll start out with a value that'll put p or q\n // right bang in the middle of their range, the functions\n // are quite sensitive so we should need too many steps\n // to bracket the root from there:\n //\n T guess = 0;\n T factor = 5;\n //\n // Convert variables to parameters of a negative binomial distribution:\n //\n T n = b;\n T sf = swap_ab ? z : 1-z;\n T sfc = swap_ab ? 1-z : z;\n T u = swap_ab ? p : q;\n T v = swap_ab ? q : p;\n if(u <= pow(sf, n))\n {\n //\n // Result is less than 1, negative binomial approximation\n // is useless....\n //\n if((p < q) != swap_ab)\n {\n guess = (std::min)(T(b * 2), T(1));\n }\n else\n {\n guess = (std::min)(T(b / 2), T(1));\n }\n }\n if(n * n * n * u * sf > 0.005)\n guess = 1 + inverse_negative_binomial_cornish_fisher(n, sf, sfc, u, v, pol);\n\n if(guess < 10)\n {\n //\n // Negative binomial approximation not accurate in this area:\n //\n if((p < q) != swap_ab)\n {\n guess = (std::min)(T(b * 2), T(10));\n }\n else\n {\n guess = (std::min)(T(b / 2), T(10));\n }\n }\n else\n factor = (v < sqrt(tools::epsilon())) ? 2 : (guess < 20 ? 1.2f : 1.1f);\n BOOST_MATH_INSTRUMENT_CODE(\"guess = \" << guess);\n //\n // Max iterations permitted:\n //\n boost::uintmax_t max_iter = policies::get_max_root_iterations();\n std::pair r = bracket_and_solve_root(f, guess, factor, swap_ab ? true : false, tol, max_iter, pol);\n if(max_iter >= policies::get_max_root_iterations())\n return policies::raise_evaluation_error(\"boost::math::ibeta_invab_imp<%1%>(%1%,%1%,%1%)\", \"Unable to locate the root within a reasonable number of iterations, closest approximation so far was %1%\", r.first, pol);\n return (r.first + r.second) / 2;\n}\n\n} // namespace detail\n\ntemplate \ntypename tools::promote_args::type \n ibeta_inva(RT1 b, RT2 x, RT3 p, const Policy& pol)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n typedef typename policies::normalise<\n Policy, \n policies::promote_float, \n policies::promote_double, \n policies::discrete_quantile<>,\n policies::assert_undefined<> >::type forwarding_policy;\n\n static const char* function = \"boost::math::ibeta_inva<%1%>(%1%,%1%,%1%)\";\n if(p == 0)\n {\n return policies::raise_overflow_error(function, 0, Policy());\n }\n if(p == 1)\n {\n return tools::min_value();\n }\n\n return policies::checked_narrowing_cast(\n detail::ibeta_inv_ab_imp(\n static_cast(b), \n static_cast(x), \n static_cast(p), \n static_cast(1 - static_cast(p)), \n false, pol), \n function);\n}\n\ntemplate \ntypename tools::promote_args::type \n ibetac_inva(RT1 b, RT2 x, RT3 q, const Policy& pol)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n typedef typename policies::normalise<\n Policy, \n policies::promote_float, \n policies::promote_double, \n policies::discrete_quantile<>,\n policies::assert_undefined<> >::type forwarding_policy;\n\n static const char* function = \"boost::math::ibetac_inva<%1%>(%1%,%1%,%1%)\";\n if(q == 1)\n {\n return policies::raise_overflow_error(function, 0, Policy());\n }\n if(q == 0)\n {\n return tools::min_value();\n }\n\n return policies::checked_narrowing_cast(\n detail::ibeta_inv_ab_imp(\n static_cast(b), \n static_cast(x), \n static_cast(1 - static_cast(q)), \n static_cast(q), \n false, pol),\n function);\n}\n\ntemplate \ntypename tools::promote_args::type \n ibeta_invb(RT1 a, RT2 x, RT3 p, const Policy& pol)\n{\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n typedef typename policies::normalise<\n Policy, \n policies::promote_float, \n policies::promote_double, \n policies::discrete_quantile<>,\n policies::assert_undefined<> >::type forwarding_policy;\n\n static const char* function = \"boost::math::ibeta_invb<%1%>(%1%,%1%,%1%)\";\n if(p == 0)\n {\n return tools::min_value();\n }\n if(p == 1)\n {\n return policies::raise_overflow_error(function, 0, Policy());\n }\n\n return policies::checked_narrowing_cast(\n detail::ibeta_inv_ab_imp(\n static_cast(a), \n static_cast(x), \n static_cast(p), \n static_cast(1 - static_cast(p)), \n true, pol),\n function);\n}\n\ntemplate \ntypename tools::promote_args::type \n ibetac_invb(RT1 a, RT2 x, RT3 q, const Policy& pol)\n{\n static const char* function = \"boost::math::ibeta_invb<%1%>(%1%, %1%, %1%)\";\n typedef typename tools::promote_args::type result_type;\n typedef typename policies::evaluation::type value_type;\n typedef typename policies::normalise<\n Policy, \n policies::promote_float, \n policies::promote_double, \n policies::discrete_quantile<>,\n policies::assert_undefined<> >::type forwarding_policy;\n\n if(q == 1)\n {\n return tools::min_value();\n }\n if(q == 0)\n {\n return policies::raise_overflow_error(function, 0, Policy());\n }\n\n return policies::checked_narrowing_cast(\n detail::ibeta_inv_ab_imp(\n static_cast(a), \n static_cast(x), \n static_cast(1 - static_cast(q)), \n static_cast(q),\n true, pol),\n function);\n}\n\ntemplate \ninline typename tools::promote_args::type \n ibeta_inva(RT1 b, RT2 x, RT3 p)\n{\n return boost::math::ibeta_inva(b, x, p, policies::policy<>());\n}\n\ntemplate \ninline typename tools::promote_args::type \n ibetac_inva(RT1 b, RT2 x, RT3 q)\n{\n return boost::math::ibetac_inva(b, x, q, policies::policy<>());\n}\n\ntemplate \ninline typename tools::promote_args::type \n ibeta_invb(RT1 a, RT2 x, RT3 p)\n{\n return boost::math::ibeta_invb(a, x, p, policies::policy<>());\n}\n\ntemplate \ninline typename tools::promote_args::type \n ibetac_invb(RT1 a, RT2 x, RT3 q)\n{\n return boost::math::ibetac_invb(a, x, q, policies::policy<>());\n}\n\n} // namespace math\n} // namespace boost\n\n#endif // BOOST_MATH_SP_DETAIL_BETA_INV_AB\n\n\n\n", "meta": {"hexsha": "f5735a84956d90f3bfdf6f0cfa8e180596f7f77d", "size": 10363, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp", "max_stars_repo_name": "189569400/ClickHouse", "max_stars_repo_head_hexsha": "0b8683c8c9f0e17446bef5498403c39e9cb483b8", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 12278.0, "max_stars_repo_stars_event_min_datetime": "2015-01-29T17:11:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:12:00.000Z", "max_issues_repo_path": "contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp", "max_issues_repo_name": "189569400/ClickHouse", "max_issues_repo_head_hexsha": "0b8683c8c9f0e17446bef5498403c39e9cb483b8", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 9469.0, "max_issues_repo_issues_event_min_datetime": "2015-01-30T05:33:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:17:21.000Z", "max_forks_repo_path": "contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp", "max_forks_repo_name": "189569400/ClickHouse", "max_forks_repo_head_hexsha": "0b8683c8c9f0e17446bef5498403c39e9cb483b8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 892.0, "max_forks_repo_forks_event_min_datetime": "2015-01-29T16:26:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T07:44:30.000Z", "avg_line_length": 31.4984802432, "max_line_length": 221, "alphanum_fraction": 0.6240470906, "num_tokens": 3094, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6039318337259583, "lm_q2_score": 0.4960938294709195, "lm_q1q2_score": 0.29960685613250526}} {"text": "/**\n * @Author: Julien Vial-Detambel \n * @Date: 2018-06-12T11:23:27+01:00\n * @Email: julien.vial-detambel@epitech.eu\n * @Project: CUDA-Based Simulator of Quantum Systems\n * @Filename: Simulator.cpp\n * @Last modified by: l3ninj\n * @Last modified time: 2018-08-23T12:13:08+02:00\n * @License: MIT License\n */\n\n#include \n#include \n#include \n\n#include \n\n#include \"MatrixStore.hpp\"\n#include \"Worker/Simulator.hpp\"\n#include \"Logger.hpp\"\n\nusing namespace TaskGraph;\nusing namespace MeasurementResultsTree;\n\nSimulator::Simulator(SimulateCircuitTask &task, IMeasurementResultsTree &measurementsTree, Matrix const &state)\n: m_task(task), m_measurementsTree(measurementsTree), m_state(state) {\n // Computing the offsets for each qregisters,\n // and total qubits number of the system.\n m_size = 0;\n for (auto ®: m_task.circuit.qreg) {\n m_qRegOffsets.insert(make_pair(reg.name, m_size));\n m_size += reg.size;\n }\n}\n\nSimulator::StepVisitor::StepVisitor(Simulator& simulator) :\nm_simulator(simulator) {}\n\nvoid Simulator::StepVisitor::operator()(const Circuit::UGate& value) {\n // Computing the offset of the target qubit\n Circuit::Qubit target = value.target;\n int id = m_simulator.m_qRegOffsets.find(target.registerName)->second;\n id += target.element;\n\n // Creating a gate according to the phi, theta and lambda parameters and\n // setting it as the target qubit transformation gate.\n using namespace std::complex_literals;\n m_simulator.m_gates[id] = Matrix(std::shared_ptr(new Tvcplxd({exp(-1i * (value.phi + value.lambda) / 2.0)\n * cos(value.theta / 2.0),\n -exp(-1i * (value.phi - value.lambda) / 2.0) * sin(value.theta / 2.0),\n exp(1i * (value.phi - value.lambda) / 2.0) * sin(value.theta / 2.0),\n exp(1i * (value.phi + value.lambda) / 2.0) * cos(value.theta / 2.0)\n })), 2, 2);\n\n // Debug logs\n LOG(Logger::DEBUG, \"Applying a U Gate:\" << \"\\nU Gate:\\n\\ttheta: \"\n << value.theta << \", phi: \" << value.phi << \", lambda: \" << value.lambda\n << \"\\n\\ttarget: \" << value.target.registerName << \"[\"\n << value.target.element << \"]\\n\" << std::endl);\n}\n\nvoid Simulator::StepVisitor::operator()(const Circuit::CXGate& value) {\n // Apparently this method requires us to normalize the state afterward\n m_simulator.m_shouldNormalize = true;\n m_simulator.m_shouldAddSecondMatrix = true;\n\n // Computing the offset of the control qubit.\n Circuit::Qubit control = value.control;\n int controlId = m_simulator.m_qRegOffsets.find(control.registerName)->second;\n controlId += control.element;\n\n // Computing the offset of the target qubit.\n Circuit::Qubit target = value.target;\n int targetId = m_simulator.m_qRegOffsets.find(target.registerName)->second;\n targetId += target.element;\n\n m_simulator.m_gates[controlId] = MatrixStore::pk0;\n m_simulator.m_extraGates[controlId] = MatrixStore::pk1;\n m_simulator.m_extraGates[targetId] = MatrixStore::x;\n\n LOG(Logger::DEBUG, \"Applying a CX Gate:\" << \"\\nCX Gate:\\n\\tcontrol: \"\n << value.control.registerName << \"[\" << value.control.element\n << \"]\\n\\ttarget: \" << value.target.registerName << \"[\"\n << value.target.element << \"]\\n\" << std::endl);\n}\n\nvoid Simulator::StepVisitor::operator()(const Circuit::Measurement& value) {\n (void)(value);\n LOG(Logger::ERROR, \"Measurement should not be present in the circuit anymore\");\n assert(true == false);\n}\n\nvoid Simulator::StepVisitor::operator()(const Circuit::Barrier& __attribute__((unused)) value) {\n // Nothing to be done for a barrier. It is the same as an identity, computationaly-wise\n (void)value;\n}\n\nvoid Simulator::StepVisitor::operator()(const Circuit::Reset& value) {\n m_simulator.m_shouldNormalize = true;\n // Computing the offset of the target qubit\n Circuit::Qubit target = value.target;\n int id = m_simulator.m_qRegOffsets.find(target.registerName)->second;\n id += target.element;\n\n m_simulator.m_gates[id] = MatrixStore::pk0;\n}\nvoid Simulator::StepVisitor::operator()(const Circuit::ConditionalGate& cGate) {\n const auto value = m_simulator.m_measurementsTree.getCregValueAtNode(cGate.testedRegister, m_simulator.m_task.measurementNodeId);\n if (value == cGate.expectedValue) { cGate.gate.apply_visitor(*this); }\n}\n\nMatrix Simulator::simulate() {\n auto visitor = StepVisitor(*this);\n // Looping through each steps of the circuit.\n for (std::vector::iterator it = m_task.circuit.steps.begin();\n it != m_task.circuit.steps.end(); ++it) {\n // LOG(Logger::DEBUG, \"State before step:\" << m_state);\n m_shouldNormalize = false;\n m_shouldAddSecondMatrix = false;\n // Initializing the gate vectors\n m_gates = std::vector(m_size, MatrixStore::i2);\n m_extraGates = std::vector(m_size, MatrixStore::i2);\n for (auto &substep: *it) {\n // Applying defined tranformations in the visitor.\n boost::apply_visitor(visitor, substep);\n }\n // Computing the new state as the dot product between the kroenecker product\n // of the transformation gates for each qubits and the actual simulator state.\n Matrix op = Matrix::kron(m_gates);\n if (m_shouldAddSecondMatrix) op = op + Matrix::kron(m_extraGates);\n // for (auto const &g : m_extraGates) {\n // LOG(Logger::ERROR, g);\n // }\n // LOG(Logger::DEBUG, \"Applying matrix:\" << op);\n // LOG(Logger::DEBUG, \"Submatrices:\" << Matrix::kron(m_gates) << Matrix::kron(m_extraGates));\n m_state = op * m_state;\n\n if (m_shouldNormalize) m_state = m_state.normalize();\n // LOG(Logger::DEBUG, \"State after step:\" << m_state);\n }\n return m_state;\n}\n", "meta": {"hexsha": "f0480b2f307932f4943239f91c4619850c6ebbe3", "size": 5590, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/Worker/Simulator.cpp", "max_stars_repo_name": "4rzael/quantum-cuda", "max_stars_repo_head_hexsha": "6c03d79f4ef68f6350e0659a1ef5a556d7915968", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-07-05T12:22:01.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-05T05:28:42.000Z", "max_issues_repo_path": "src/Worker/Simulator.cpp", "max_issues_repo_name": "4rzael/quantum-cuda", "max_issues_repo_head_hexsha": "6c03d79f4ef68f6350e0659a1ef5a556d7915968", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Worker/Simulator.cpp", "max_forks_repo_name": "4rzael/quantum-cuda", "max_forks_repo_head_hexsha": "6c03d79f4ef68f6350e0659a1ef5a556d7915968", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-11-14T17:58:11.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-14T17:58:11.000Z", "avg_line_length": 39.0909090909, "max_line_length": 131, "alphanum_fraction": 0.6976744186, "num_tokens": 1523, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191337850932, "lm_q2_score": 0.42250463481418826, "lm_q1q2_score": 0.2995638701961429}} {"text": "// STD headers\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Boost headers\n#include \n#include \n\n// Cereal headers\n#include \n#include \n\n// Gurobi headers\n#include \n\n// Custom headers\n#include \"flow_dict.hpp\"\n#include \"simulator.hpp\"\n#include \"utils.hpp\"\n\n// Typedefs\nnamespace bopt = boost::program_options;\ntypedef std::tuple Edge; // Format: (flow_id, in_cache, src, dst, cost)\n\n// Constant hyperparameters\nconstexpr unsigned int kNumThreads = 24;\n\n/**\n * Implements a Multi-Commodity Min-Cost Flow-based\n * solver for the Delayed Hits caching problem.\n */\nclass MCMCFSolver {\nprivate:\n typedef std::vector Indices;\n\n // Trace and cache parameters\n const uint z_;\n const uint c_;\n const bool is_forced_;\n const size_t trace_len_;\n const std::string trace_file_path_;\n const std::string model_file_prefix_;\n const std::string packets_file_path_;\n const std::vector trace_;\n\n // Housekeeping\n std::vector solution_;\n std::unordered_set cache_node_idxs_;\n std::unordered_map indices_;\n boost::bimap idx_to_nodename_;\n std::unordered_map idx_to_miss_cost_;\n std::unordered_map sink_nodes_;\n std::unordered_map cache_interval_start_idxs_;\n\n // \"Split nodes\" are used to enforce forced admission, if required.\n // We detect nodes where the forced admission constraint *might* be\n // violated (i.e. an object doesn't remain in the cache for atleast\n // one timestep), and add manually a constraint that enforces this.\n std::unordered_set split_node_idxs_;\n\n // Internal helper methods\n double getMissCostStartingAt(const size_t idx) const;\n const std::string& cchNodeForMemAt(const size_t idx) const;\n size_t getNextMemNodeIdx(const size_t idx, const std::string& flow_id,\n std::unordered_map& next_idxs_map) const;\n\n // Thread-safe, concurrent helper methods\n void populateOutOfCchEdgesConcurrent(\n const std::list& flow_ids,\n std::list& edges, std::unordered_set& cache_node_idxs);\n\n void populateCchCapacityConstraintsConcurrent(\n const std::pair range,\n const belatedly::FlowDict& flows, std::list& exprs) const;\n\n // Setup and checkpointing\n void setup();\n bool loadOptimizedModelSolution(belatedly::FlowDict& flows);\n void saveOptimizedModelSolution(const belatedly::FlowDict& flows) const;\n\n // Model creation\n void populateOutOfCchEdges(std::list& all_edges);\n void createFlowVariables(GRBModel& model, belatedly::FlowDict&\n flows, const std::list& edges) const;\n\n void populateCchCapacityConstraints(\n GRBModel& model, const belatedly::FlowDict& flows) const;\n\n void populateSplitNodeFlowConstraints(\n GRBModel& model, const belatedly::FlowDict& flows) const;\n\n void populateFlowConservationConstraints(\n GRBModel& model, const belatedly::FlowDict& flows) const;\n\n void addMissCostStartingAt(const size_t start_idx,\n const double coefficient,\n std::vector& packets) const;\n\n // Cost computation and validation\n double getCostLowerBound(const belatedly::FlowDict& flows,\n const std::list& edges) const;\n\n double getCostUpperBoundAndValidateSolution(\n const belatedly::FlowDict& flows, const std::list& edges) const;\n\npublic:\n MCMCFSolver(const std::string& trace_fp, const std::string& model_fp,\n const std::string& packets_fp, const bool forced, const\n uint z, const uint c, const std::vector& trace) :\n z_(z), c_(c), is_forced_(forced), trace_len_(trace.size()),\n trace_file_path_(trace_fp), model_file_prefix_(model_fp),\n packets_file_path_(packets_fp), trace_(trace) {}\n\n void solve();\n};\n\n/**\n * Given an index, returns the corresponding cache node.\n *\n * Thread-safe.\n */\nconst std::string& MCMCFSolver::cchNodeForMemAt(const size_t idx) const {\n return idx_to_nodename_.left.at(idx);\n}\n\n/**\n * Returns the cost of a cache miss starting at idx.\n *\n * Thread-safe.\n */\ndouble MCMCFSolver::getMissCostStartingAt(const size_t idx) const {\n const std::string& flow_id = trace_[idx];\n double miss_cost = z_;\n\n // Iterate over the next z timesteps, and add the\n // latency cost corresponding to each subsequent\n // packet of the same flow.\n for (size_t offset = 1; offset < z_; offset++) {\n if (idx + offset >= trace_len_) { break; }\n else if (trace_[idx + offset] == flow_id) {\n miss_cost += (z_ - offset);\n }\n }\n return miss_cost;\n}\n\n/**\n * Returns the index of the first mem node corresponding to the given\n * flow ID occuring after idx. If no reference to this flow is found\n * in (idx, trace_len_), returns maxval.\n *\n * The state for each flow is cached in next_idxs_map. This dict must\n * be cleared before starting a new operation (that is, when indices\n * are no longer expected to continue increasing monotonically).\n *\n * Thread-safe.\n */\nsize_t MCMCFSolver::getNextMemNodeIdx(\n const size_t idx, const std::string& flow_id,\n std::unordered_map& next_idxs_map) const {\n const std::vector& indices = indices_.at(flow_id);\n size_t indices_len = indices.size();\n\n while ((next_idxs_map[flow_id] < indices_len) &&\n (indices[next_idxs_map[flow_id]] <= idx)) {\n next_idxs_map[flow_id]++;\n }\n // If the next index is beyond the idxs list for\n // this flow, return the corresponding sink node.\n size_t next_idx = next_idxs_map[flow_id];\n if (next_idx == indices_len) {\n return std::numeric_limits::max();\n }\n else {\n size_t next_mem_idx = indices[next_idx];\n assert(trace_[next_mem_idx] == flow_id);\n return next_mem_idx;\n }\n}\n\n/**\n * Attempts to load the optimal solution and the flow mappings\n * for the given model. Returns true if successful, else false.\n */\nbool MCMCFSolver::loadOptimizedModelSolution(belatedly::FlowDict& flows) {\n if (model_file_prefix_.empty()) { return false; }\n std::ifstream solution_ifs(model_file_prefix_ + \".sol\");\n const std::string flows_fp = model_file_prefix_ + \".flows\";\n\n // Either of the required model files is missing, indicating failure\n if (!solution_ifs.good() || !std::ifstream(flows_fp).good()) {\n return false;\n }\n // Load the solutions vector\n {\n cereal::BinaryInputArchive ar(solution_ifs);\n ar(solution_);\n }\n // Load the flow mappings\n flows.loadFlowMappings(flows_fp);\n\n // Sanity check: The number of decision variables should\n // be equal to the number of entries in the flows map.\n assert(solution_.size() == flows.numVariables());\n return true;\n}\n\n/**\n * Saves the optimal solution and flow mappings to disk.\n */\nvoid MCMCFSolver::saveOptimizedModelSolution(\n const belatedly::FlowDict& flows) const {\n\n if (model_file_prefix_.empty()) { return; }\n std::ofstream solution_ofs(model_file_prefix_ + \".sol\");\n const std::string flows_fp = model_file_prefix_ + \".flows\";\n\n // Save the solutions vector\n cereal::BinaryOutputArchive oarchive(solution_ofs);\n oarchive(solution_);\n\n // Save the flow mappings\n flows.saveFlowMappings(flows_fp);\n}\n\n/**\n * Populate the indices map and internal data structures.\n */\nvoid MCMCFSolver::setup() {\n size_t num_nonempty_packets = 0;\n for (size_t idx = 0; idx < trace_len_; idx++) {\n const std::string& flow_id = trace_[idx];\n\n // If the packet is non-empty, append the idx to\n // the corresponding flow's idxs. Also, populate\n // the miss-costs map.\n if (!flow_id.empty()) {\n num_nonempty_packets++;\n indices_[flow_id].push_back(idx);\n idx_to_miss_cost_[idx] = getMissCostStartingAt(idx);\n }\n // Found a possible violation of forced admission; track this as a split node\n if (is_forced_ && !flow_id.empty() && (idx > 0) && (idx < trace_len_ - z_) &&\n (flow_id == trace_[idx - 1]) && (flow_id == trace_[idx + z_])) {\n split_node_idxs_.insert(idx);\n }\n // Populate the nodenames map\n idx_to_nodename_.insert(boost::bimap::value_type(\n idx, \"cch_t\" + std::to_string(idx + z_ - 1) + \"_\" + flow_id));\n }\n // Populate the sink nodes map and\n // prime the cache intervals map.\n for (const auto& iter : indices_) {\n const std::string& flow_id = iter.first;\n sink_nodes_[flow_id] = (\"x_\" + flow_id);\n cache_interval_start_idxs_[flow_id];\n }\n // Debug\n std::cout << \"Finished setup with \" << trace_len_\n << \" packets (\" << num_nonempty_packets\n << \" nonempty), \" << indices_.size()\n << \" flows.\" << std::endl;\n}\n\n/**\n * Helper method. Populates the out-of-cache edges (mem->cch/admittance,\n * and cch->mem/eviction) for the given flow IDs in a thread-safe manner.\n *\n * Important note: This method relies on the fact that separate threads\n * operate on disjoint sets of flow IDs (and only ever access different\n * STL containers concurrently), precluding the need for mutexes.\n *\n * Thread-safe.\n */\nvoid MCMCFSolver::populateOutOfCchEdgesConcurrent(\n const std::list& flow_ids, std::list& edges,\n std::unordered_set& local_cache_node_idxs) {\n\n // Iterate over the given flow IDs to populate the edges list\n std::unordered_map next_idxs_map;\n for (const std::string& flow_id : flow_ids) {\n std::string evicted_reference = std::string();\n bool has_flow_started = false;\n\n // Iterate over each timestep and fetch the next mem reference\n for (size_t idx = 0; idx < trace_len_; idx++) {\n const std::string& trace_flow_id = trace_[idx];\n bool is_same_flow = (!trace_flow_id.empty() &&\n (trace_flow_id == flow_id));\n if (has_flow_started) {\n\n // Fetch the next mem reference corresponding to this flow\n const size_t next_reference_idx = getNextMemNodeIdx(\n idx + z_ - 1, flow_id, next_idxs_map);\n\n const bool is_dst_sink_node = (next_reference_idx ==\n std::numeric_limits::max());\n\n // Fetch the dst node for this out-of-cache edge\n const std::string& next_reference = is_dst_sink_node ?\n sink_nodes_.at(flow_id) :\n cchNodeForMemAt(next_reference_idx);\n if (is_same_flow) {\n // In optional admission, unconditionally create an\n // outedge from this node to the next mem reference.\n if (!is_forced_) {\n evicted_reference = next_reference;\n edges.push_back(std::make_tuple(\n flow_id, false, cchNodeForMemAt(idx), next_reference,\n (is_dst_sink_node ? 0.0 : idx_to_miss_cost_.at(next_reference_idx)))\n );\n }\n // The following node in the trace (mem_t{idx + z}) maps to\n // this flow, but the previous node in the caching sequence\n // (cch_t{idx + z - 1}) also maps to it. Thus, this is the\n // final opportunity to reach mem_t{idx + z}, and we create\n // an edge to it.\n else if (split_node_idxs_.find(idx) != split_node_idxs_.end()) {\n assert(!is_dst_sink_node);\n edges.push_back(std::make_tuple(\n flow_id, false, cchNodeForMemAt(idx),\n next_reference, idx_to_miss_cost_.at(next_reference_idx))\n );\n }\n // Discard the next mem reference for this flow\n else {\n evicted_reference.clear();\n }\n\n // Mark this idx as the start of a new interval for this flow\n local_cache_node_idxs.insert(idx);\n cache_interval_start_idxs_.at(flow_id).push_back(idx);\n }\n // If we did not already created an eviction edge to the\n // next mem reference for this flow, create one to it.\n else if (evicted_reference != next_reference) {\n evicted_reference = next_reference;\n edges.push_back(std::make_tuple(\n flow_id, false, cchNodeForMemAt(idx), next_reference,\n (is_dst_sink_node ? 0.0 : idx_to_miss_cost_.at(next_reference_idx)))\n );\n\n // Mark this idx as the start of a new interval for this flow\n local_cache_node_idxs.insert(idx);\n cache_interval_start_idxs_.at(flow_id).push_back(idx);\n }\n }\n // The flow has not yet started and the packet at this timestep\n // belongs to this flow, indicating that this is the first ever\n // request to it.\n else if (is_same_flow) {\n has_flow_started = true;\n\n // In optional admission, unconditionally create an\n // outedge from this node to the next mem reference.\n if (!is_forced_) {\n // Fetch the next mem reference corresponding to this flow\n const size_t next_reference_idx = getNextMemNodeIdx(\n idx + z_ - 1, flow_id, next_idxs_map);\n\n const bool is_dst_sink_node = (next_reference_idx ==\n std::numeric_limits::max());\n\n // Fetch the dst node for this out-of-cache edge\n const std::string& next_reference = is_dst_sink_node ?\n sink_nodes_.at(flow_id) :\n cchNodeForMemAt(next_reference_idx);\n evicted_reference = next_reference;\n edges.push_back(std::make_tuple(\n flow_id, false, cchNodeForMemAt(idx), next_reference,\n (is_dst_sink_node ? 0.0 : idx_to_miss_cost_.at(next_reference_idx)))\n );\n }\n // Mark this idx as the start of a new interval for this flow\n local_cache_node_idxs.insert(idx);\n cache_interval_start_idxs_.at(flow_id).push_back(idx);\n }\n }\n }\n}\n\n/**\n * Populates the out-of-cache (eviction and admittance) edges.\n */\nvoid MCMCFSolver::populateOutOfCchEdges(std::list& all_edges) {\n size_t num_out_of_cch_edges = 0;\n size_t num_total_flows = indices_.size();\n size_t num_flows_per_thread = int(ceil(num_total_flows /\n static_cast(kNumThreads)));\n\n // Temporary containers for each thread\n size_t num_flows_allotted = 0;\n std::array, kNumThreads> edges;\n std::array, kNumThreads> flow_ids;\n std::array, kNumThreads> local_cache_node_idxs;\n\n // Partition the entire set of flow IDs into kNumThreads disjoint sets\n auto iter = indices_.begin();\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n for (size_t i = 0; (i < num_flows_per_thread) &&\n (iter != indices_.end()); i++, iter++) {\n num_flows_allotted++;\n flow_ids[t_idx].push_back(iter->first);\n }\n }\n // Sanity check\n assert(num_flows_allotted == num_total_flows);\n\n // Launch kNumThreads on the corresponding sets of flow IDs\n std::thread workers[kNumThreads];\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n workers[t_idx] = std::thread(&MCMCFSolver::populateOutOfCchEdgesConcurrent, this,\n std::ref(flow_ids[t_idx]), std::ref(edges[t_idx]),\n std::ref(local_cache_node_idxs[t_idx]));\n }\n // Wait for all the worker threads to finish execution\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n workers[t_idx].join();\n }\n // Then, combine their results\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n num_out_of_cch_edges += edges[t_idx].size();\n all_edges.splice(all_edges.end(), edges[t_idx]);\n cache_node_idxs_.insert(local_cache_node_idxs[t_idx].begin(),\n local_cache_node_idxs[t_idx].end());\n }\n // Next, sort the cache intervals for each flow in-place\n for (auto& iter : cache_interval_start_idxs_) {\n std::vector& start_idxs = iter.second;\n std::sort(start_idxs.begin(), start_idxs.end());\n }\n // Finally, for the last packet in the trace, unconditionally\n // create an outedge to the corresponding flow's sink node.\n size_t idx = (trace_len_ - 1);\n const std::string& flow_id = trace_[idx];\n if (is_forced_ && !flow_id.empty()) {\n num_out_of_cch_edges++;\n all_edges.push_back(std::make_tuple(flow_id, false,\n cchNodeForMemAt(idx),\n sink_nodes_.at(flow_id), 0.0));\n }\n // Debug\n std::cout << \"Finished populating \" << num_out_of_cch_edges\n << \" out-of-cache edges concurrently, using \"\n << kNumThreads << \" threads.\" << std::endl;\n}\n\n/**\n * Given a list of edges, populates the flow tupledict.\n */\nvoid MCMCFSolver::\ncreateFlowVariables(GRBModel& model, belatedly::FlowDict& flows,\n const std::list& edges) const {\n size_t num_total_cache_intervals = 0;\n\n // First, create variables representing mem->cch and cch->mem edges\n for (const Edge& edge : edges) {\n flows.addVariable(std::get<0>(edge),\n std::get<1>(edge),\n std::get<2>(edge),\n std::get<3>(edge),\n std::get<4>(edge));\n }\n // Next, for every flow, create decision variables\n // corresponding to each possible caching interval.\n for (const auto& iter : cache_interval_start_idxs_) {\n const std::string& flow_id = iter.first;\n const std::vector& start_idxs = iter.second;\n const size_t num_intervals = (start_idxs.size() - 1);\n\n // Iterate over each interval\n for (size_t i = 0; i < num_intervals; i++) {\n size_t idx = start_idxs[i];\n size_t next_idx = start_idxs[i + 1];\n\n // Sanity check: Both indices should be in the nodes set\n assert((cache_node_idxs_.find(idx) != cache_node_idxs_.end()) &&\n (cache_node_idxs_.find(next_idx) != cache_node_idxs_.end()));\n\n // Create a decision variable corresponding to cch_{idx}->cch_{next_idx}\n num_total_cache_intervals++;\n flows.addVariable(flow_id, true,\n cchNodeForMemAt(idx),\n cchNodeForMemAt(next_idx), 0.0);\n }\n }\n // Finally, update the model\n model.update();\n\n // Debug\n std::cout << \"Finished creating \" << flows.numVariables() << \" flow variables (for \"\n << edges.size() << \" edges, plus \" << num_total_cache_intervals\n << \" caching intervals).\" << std::endl;\n}\n\n/**\n * Helper method. Populates the cache capacity constraints for\n * the given range of trace indices in a thread-safe manner.\n *\n * Thread-safe.\n */\nvoid MCMCFSolver::populateCchCapacityConstraintsConcurrent(\n const std::pair range, const belatedly::\n FlowDict& flows, std::list& exprs) const {\n std::unordered_map decision_variables;\n std::unordered_map current_idxs;\n\n // Starting index is out-of-bounds, do nothing\n if (range.first >= trace_len_) { return; }\n\n // First, for each flow ID, forward its current iterator idx\n // to point to the appropriate location in its indices list.\n for (const auto& iter : cache_interval_start_idxs_) {\n const std::vector& intervals = iter.second;\n const std::string& flow_id = iter.first;\n\n size_t i = 0;\n while (i < (intervals.size() - 1) &&\n range.first > intervals[i + 1]) { i++; }\n\n // Update the current iterator idx\n current_idxs[flow_id] = i;\n }\n // Next, generate a linear-expression corresponding to the sum of\n // all flow decision variables at every timestep, and impose that\n // it is LEQ the cache size as a constraint.\n for (size_t idx = range.first; idx < range.second; idx++) {\n if (cache_node_idxs_.find(idx) ==\n cache_node_idxs_.end()) { continue; }\n\n bool is_split_node = (split_node_idxs_.find(idx) !=\n split_node_idxs_.end());\n GRBLinExpr node_capacity_expr;\n bool is_expr_changed = false;\n\n // Update the current decision variable for each\n // flow and add it to the LHS of the constraints.\n for (const auto& iter : cache_interval_start_idxs_) {\n const std::string& flow_id = iter.first;\n const std::vector& intervals = iter.second;\n bool is_split_node_for_flow = (is_split_node &&\n (trace_[idx] == flow_id));\n\n // If this trace index either precedes the first decision\n // variable, or is either at or beyond the last decision\n // variable for this flow, do nothing.\n size_t i = current_idxs[flow_id];\n if (idx < intervals[0] || idx >= intervals.back()) {\n continue;\n }\n // Reached the first interval or the end\n // of the current interval for this flow.\n else if ((decision_variables.find(flow_id) ==\n decision_variables.end()) ||\n (idx == intervals[i + 1])) {\n\n // If this is the end of the current\n // interval, update the idx iterator.\n if (idx == intervals[i + 1]) {\n current_idxs[flow_id] = ++i;\n }\n // Fetch the current interval\n size_t start_idx = intervals[i];\n size_t end_idx = intervals[i + 1];\n\n // This is a regular node\n GRBVar decision_variable = (\n flows.getVariable(flow_id, true,\n cchNodeForMemAt(start_idx),\n cchNodeForMemAt(end_idx)));\n\n // Update the decision variable for this flow\n decision_variables[flow_id] = decision_variable;\n node_capacity_expr += decision_variable;\n is_expr_changed = true;\n }\n // Else, add the current decision variable to the expression\n else {\n GRBVar decision_variable = decision_variables.at(flow_id);\n node_capacity_expr += decision_variable;\n assert(!is_split_node_for_flow);\n }\n }\n // Finally, add the expression as a cache constraints\n if (is_expr_changed) { exprs.push_back(node_capacity_expr); }\n }\n}\n\n/**\n * Populates the cache capacity constraints for the given flow variables.\n */\nvoid MCMCFSolver::populateCchCapacityConstraints(\n GRBModel& model, const belatedly::FlowDict& flows) const {\n std::array, kNumThreads> exprs;\n std::thread workers[kNumThreads];\n size_t num_constraints = 0;\n\n // Partition the trace into kNumThreads disjoint sets\n size_t start_idx = 0;\n size_t idxs_per_thread = int(ceil(trace_len_ /\n static_cast(kNumThreads)));\n\n // Launch kNumThreads on the corresponding range of indices\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n size_t end_idx = std::min(trace_len_,\n start_idx + idxs_per_thread);\n\n workers[t_idx] = std::thread(\n &MCMCFSolver::populateCchCapacityConstraintsConcurrent, this,\n std::make_pair(start_idx, end_idx), std::ref(flows),\n std::ref(exprs[t_idx]));\n\n // Update the starting idx\n start_idx = end_idx;\n }\n // Wait for all the worker threads to finish execution\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n workers[t_idx].join();\n }\n // Populate the model constraints\n for (size_t t_idx = 0; t_idx < kNumThreads; t_idx++) {\n for (auto& expr : exprs[t_idx]) {\n num_constraints++;\n model.addConstr(expr, GRB_LESS_EQUAL, c_, \"\");\n }\n exprs[t_idx].clear();\n }\n // Debug\n std::cout << \"Finished adding \" << num_constraints << \" arc-capacity\"\n << \" constraints for cch->cch edges concurrently, using \"\n << kNumThreads << \" threads.\" << std::endl;\n}\n\n/**\n * Populates flow constraints for split nodes. These ensure that once\n * flow enters the cache, it remains there for at least one timestep.\n */\nvoid MCMCFSolver::populateSplitNodeFlowConstraints(\n GRBModel& model, const belatedly::FlowDict& flows) const {\n size_t num_split_node_constraints = 0;\n\n for (const size_t idx : split_node_idxs_) {\n const std::string& flow_id = trace_[idx];\n num_split_node_constraints++;\n\n // Fetch the decision variable corresponding\n // to the cch_{idx}->next_mem_node edge.\n const GRBVar outflow = flows.getVariable(\n flow_id, false, cchNodeForMemAt(idx),\n cchNodeForMemAt(idx + z_));\n\n // Fetch the expression corresponding\n // to the mem_{idx}->cch_{idx} edge.\n const GRBLinExpr inflow = (\n flows.sumAcrossSrcNodes(flow_id, false,\n cchNodeForMemAt(idx)));\n\n // Ensure that the outflow is LEQ (1 - inflow)\n model.addConstr(outflow + inflow, GRB_LESS_EQUAL, 1, \"\");\n }\n // Debug\n std::cout << \"Finished populating \" << num_split_node_constraints\n << \" flow constraints for split nodes.\" << std::endl;\n}\n\n/**\n * Populates the flow conservation constraints for all nodes.\n */\nvoid MCMCFSolver::populateFlowConservationConstraints(\n GRBModel& model, const belatedly::FlowDict& flows) const {\n\n // Flow-conservation constraints for sink nodes\n size_t num_sink_node_constraints = 0;\n for (const auto& iter : indices_) {\n num_sink_node_constraints++;\n const std::string& flow_id = iter.first;\n const std::string& node = sink_nodes_.at(flow_id);\n model.addConstr(flows.sumAcrossSrcNodes(flow_id, node), GRB_EQUAL, 1, \"\");\n }\n // Debug\n std::cout << \"Finished adding \" << num_sink_node_constraints\n << \" flow-conservation constraints for sink nodes.\"\n << std::endl;\n\n // Flow-conservation constraints for cache nodes\n size_t num_cache_node_constraints = 0;\n for (const auto& iter : cache_interval_start_idxs_) {\n const std::string& flow_id = iter.first;\n const std::vector& start_idxs = iter.second;\n\n for (size_t idx : start_idxs) {\n num_cache_node_constraints++;\n const std::string& node = cchNodeForMemAt(idx);\n assert(cache_node_idxs_.find(idx) != cache_node_idxs_.end());\n\n // This is the source node for this flow\n if (idx == start_idxs.front()) {\n model.addConstr(flows.sumAcrossDstNodes(flow_id, node), GRB_EQUAL, 1, \"\");\n }\n // Else, this is a regular node\n else {\n model.addConstr(flows.sumAcrossSrcNodes(flow_id, node), GRB_EQUAL,\n flows.sumAcrossDstNodes(flow_id, node), \"\");\n }\n }\n }\n // Debug\n std::cout << \"Finished adding \" << num_cache_node_constraints\n << \" flow-conservation constraints for cache nodes.\"\n << std::endl;\n}\n\n/**\n * Helper method. Given a start idx and cost coefficient (flow fraction),\n * updates latencies of subsequent same-flow packets that occur within z\n * timesteps of start_idx.\n */\nvoid MCMCFSolver::\naddMissCostStartingAt(const size_t start_idx, const double coefficient,\n std::vector& packets) const {\n if (utils::DoubleApproxEqual(coefficient, 0.)) { return; }\n\n // Iterate over the next z timesteps, and add the weighted\n // latency cost to each subsequent packet of the same flow.\n const std::string& flow_id = trace_[start_idx];\n for (size_t offset = 0; offset < z_; offset++) {\n const size_t idx = start_idx + offset;\n\n if (idx >= trace_len_) { break; }\n else if (trace_[idx] == flow_id) {\n packets[idx].addLatency((z_ - offset) * coefficient);\n }\n }\n}\n\n/**\n * Returns a (tight) lower-bound on the cost of the LP solution.\n */\ndouble MCMCFSolver::getCostLowerBound(const belatedly::FlowDict& flows,\n const std::list& edges) const {\n // Create packets corresponding to each timestep\n std::vector processed_packets;\n for (const std::string& flow_id : trace_) {\n processed_packets.push_back(utils::Packet(flow_id));\n }\n // Update the packet latency corresponding\n // to the first occurence of each flow.\n for (const auto& elem : indices_) {\n const size_t src_idx = elem.second.front();\n addMissCostStartingAt(src_idx, 1., processed_packets);\n }\n // Next, add the latency cost of flow\n // routed through out-of-cch edges.\n for (const auto& edge : edges) {\n const bool in_cache = std::get<1>(edge);\n const std::string& src = std::get<2>(edge);\n const std::string& dst = std::get<3>(edge);\n const std::string& flow_id = std::get<0>(edge);\n\n // This is an out-of-cch edge and dst is not a sink node\n if (!in_cache && dst != sink_nodes_.at(flow_id)) {\n double flow_fraction = solution_[\n flows.getVariableIdx(flow_id, in_cache, src, dst)];\n\n size_t dst_idx = idx_to_nodename_.right.at(dst);\n addMissCostStartingAt(dst_idx, flow_fraction,\n processed_packets);\n }\n }\n // Compute the total latency for this solution\n double total_latency = 0;\n for (const utils::Packet& packet : processed_packets) {\n const std::string& flow_id = packet.getFlowId();\n const double latency = packet.getTotalLatency();\n if (!flow_id.empty()) {\n\n // Sanity check: For non-empty packets, latency should be in [0, z]\n assert(utils::DoubleApproxGreaterThanOrEqual(latency, 0.) &&\n utils::DoubleApproxGreaterThanOrEqual(z_, latency));\n\n total_latency += latency;\n }\n // Else, for empty packets, do nothing\n else { assert(latency == 0.); }\n }\n return total_latency;\n}\n\n/**\n * Validates the computed LP solution.\n */\ndouble MCMCFSolver::getCostUpperBoundAndValidateSolution(\n const belatedly::FlowDict& flows, const std::list& edges) const {\n std::vector> evictions;\n std::vector> inductions;\n\n // Parse the eviction schedule from the computed LP solution\n bool is_solution_integral = true;\n size_t num_fractional_vars = 0;\n for (const auto& edge : edges) {\n const bool in_cache = std::get<1>(edge);\n const std::string& flow_id = std::get<0>(edge);\n\n // If this is an out-of-cch edge, fetch the\n // decision variable corresponding to it.\n if (!in_cache) {\n const size_t src_idx = idx_to_nodename_.right.at(\n std::get<2>(edge)) + z_ - 1;\n\n const size_t dst_idx =\n (std::get<3>(edge) == sink_nodes_.at(flow_id)) ?\n std::numeric_limits::max() :\n idx_to_nodename_.right.at(std::get<3>(edge)) + z_ - 1;\n\n double value = solution_[flows.getVariableIdx(\n flow_id, in_cache, std::get<2>(edge),\n std::get<3>(edge))];\n\n // The solution has non-integral variables\n if (!utils::DoubleApproxEqual(value, 1.) &&\n !utils::DoubleApproxEqual(value, 0.)) {\n is_solution_integral = false;\n num_fractional_vars++;\n }\n // Perform an eviction at this node\n if (value > 0.) {\n evictions.push_back(std::make_tuple(src_idx, flow_id, value));\n if (dst_idx != std::numeric_limits::max()) {\n inductions.push_back(std::make_tuple(dst_idx, flow_id, value));\n }\n }\n }\n }\n // Populate the inductions list for source nodes\n for (const auto& item : indices_) {\n const std::string& flow_id = item.first;\n const size_t src_idx = item.second.front() + z_ - 1;\n inductions.push_back(std::make_tuple(src_idx, flow_id, 1.));\n }\n // Sort the eviction schedule\n std::sort(evictions.begin(), evictions.end(), [](\n const std::tuple& a,\n const std::tuple& b) {\n return (std::get<0>(a) < std::get<0>(b)); });\n\n // Sort the induction schedule\n std::sort(inductions.begin(), inductions.end(), [](\n const std::tuple& a,\n const std::tuple& b) {\n return (std::get<0>(a) < std::get<0>(b)); });\n // Debug\n std::cout << \"Solution is \"\n << (is_solution_integral ? \"INTEGRAL.\" : \"FRACTIONAL.\") << std::endl;\n\n // For fractional solutions, output the fraction of non-integer decision variables\n if (!is_solution_integral) {\n double percentage_fractional = (num_fractional_vars * 100.) / flows.numVariables();\n std::cout << \"Warning: Solution has \" << num_fractional_vars << \" fractional \"\n << \"decision variables (\" << flows.numVariables() << \" in total => \"\n << std::fixed << std::setprecision(2) << percentage_fractional\n << \"%).\" << std::endl;\n }\n // Finally, run the cache simulator and validate the computed LP solution\n belatedly::CacheSimulator simulator(packets_file_path_, is_solution_integral,\n is_forced_, z_, c_, trace_, evictions,\n inductions);\n return simulator.run();\n}\n\n/**\n * Solve the MCMCF instance for the given trace.\n */\nvoid MCMCFSolver::solve() {\n\n // Populate the internal structs\n setup();\n std::list edges;\n populateOutOfCchEdges(edges);\n\n // Create optimization model\n GRBEnv env = GRBEnv();\n GRBModel model = GRBModel(env);\n belatedly::FlowDict flows = belatedly::FlowDict(model);\n\n // If the solution does not already exist, re-run the optimizer\n bool is_loaded_from_file = loadOptimizedModelSolution(flows);\n double opt_cost = std::numeric_limits::max();\n if (!is_loaded_from_file) {\n\n // Create variables, populate constraints\n createFlowVariables(model, flows, edges);\n populateCchCapacityConstraints(model, flows);\n populateSplitNodeFlowConstraints(model, flows);\n populateFlowConservationConstraints(model, flows);\n\n // Compute the optimal solution\n model.set(GRB_IntAttr_ModelSense, GRB_MINIMIZE);\n model.set(GRB_DoubleParam_NodefileStart, 5);\n model.set(GRB_IntParam_Threads, 1);\n model.set(GRB_IntParam_Method, 1);\n model.optimize();\n\n // Populate the solution vector\n int status = model.get(GRB_IntAttr_Status);\n assert(status == GRB_OPTIMAL); // Sanity check\n for (size_t idx = 0; idx < flows.numVariables(); idx++) {\n solution_.push_back(flows.getVariableAt(idx).get(GRB_DoubleAttr_X));\n }\n\n // Save the optimal solution\n saveOptimizedModelSolution(flows);\n\n // Fetch the optimal cost\n opt_cost = model.get(GRB_DoubleAttr_ObjVal);\n for (const auto& iter : indices_) {\n size_t first_idx = iter.second.front();\n opt_cost += idx_to_miss_cost_.at(first_idx);\n }\n\n // Print the cost corresponding to the optimal solution\n std::cout << \"Optimal cost is: \" << std::fixed\n << std::setprecision(3) << opt_cost\n << std::endl << std::endl;\n }\n\n // Note: This point onwards, we cannot assume that the Gurobi model parameters are\n // available (since the solution may have been loaded from file). Instead, we use\n // the flow mappings and the solutions vector in the remainder of the pipeline.\n double lower_bound = getCostLowerBound(flows, edges);\n double upper_bound = getCostUpperBoundAndValidateSolution(flows, edges);\n double delta_percent = ((upper_bound - lower_bound) / lower_bound) * 100;\n\n // Debug\n std::cout << \"Lower-bound (LB) on the total latency cost is: \"\n << std::fixed << std::setprecision(3) << lower_bound\n << \".\" << std::endl;\n\n std::cout << \"Upper-bound (UB) on the total latency cost is: \"\n << std::fixed << std::setprecision(3) << upper_bound\n << \" (\" << delta_percent << \"% worse than LB).\"\n << std::endl << std::endl;\n\n // If the model was solved in this instance, also validate the opt_cost\n if (!is_loaded_from_file) {\n assert(utils::DoubleApproxEqual(opt_cost, lower_bound, 1e-2));\n }\n}\n\nint main(int argc, char **argv) {\n // Parameters\n uint z;\n double c_scale;\n std::string trace_fp;\n std::string model_fp;\n std::string packets_fp;\n\n // Program options\n bopt::variables_map variables;\n bopt::options_description desc{\"BELATEDLY's MCMCF-based solver for\"\n \" the Delayed Hits caching problem\"};\n try {\n // Command-line arguments\n desc.add_options()\n (\"help\", \"Prints this message\")\n (\"trace\", bopt::value(&trace_fp)->required(), \"Input trace file path\")\n (\"cscale\", bopt::value(&c_scale)->required(), \"Parameter: Cache size (%Concurrent Flows)\")\n (\"zfactor\", bopt::value(&z)->required(), \"Parameter: Z\")\n (\"model\", bopt::value(&model_fp)->default_value(\"\"), \"[Optional] Output model file prefix (for checkpointing)\")\n (\"packets\", bopt::value(&packets_fp)->default_value(\"\"), \"[Optional] Output packets file path\")\n (\"forced,f\", \"[Optional] Use forced admission\");\n\n // Parse model parameters\n bopt::store(bopt::parse_command_line(argc, argv, desc), variables);\n\n // Handle help flag\n if (variables.count(\"help\")) {\n std::cout << desc << std::endl;\n return 0;\n }\n bopt::notify(variables);\n }\n // Flag argument errors\n catch(const bopt::required_option& e) {\n std::cerr << \"Error: \" << e.what() << std::endl;\n return 1;\n }\n catch(...) {\n std::cerr << \"Unknown Error.\" << std::endl;\n return 1;\n }\n\n // Use forced admission?\n bool is_forced = (variables.count(\"forced\") != 0);\n\n // Parse the trace file, and compute the absolute cache size\n std::vector trace = utils::parseTrace(trace_fp);\n size_t num_cfs = utils::getFlowCounts(trace).num_concurrent_flows;\n uint c = std::max(1u, static_cast(round((num_cfs * c_scale) / 100.)));\n\n // Debug\n std::cout << \"Optimizing trace: \" << trace_fp << \" (with \" << num_cfs\n << \" concurrent flows) using z = \" << z << \", c = \" << c\n << \", and \" << (is_forced ? \"forced\" : \"optional\")\n << \" admission.\" << std::endl;\n\n // Instantiate the solver and optimize\n MCMCFSolver solver(trace_fp, model_fp, packets_fp,\n is_forced, z, c, trace);\n solver.solve();\n}\n", "meta": {"hexsha": "8851eb91b640daf6f65521884f718c6b6d402a14", "size": 41327, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "belatedly/src/belatedly.cpp", "max_stars_repo_name": "Ahziu/Delayed-Hits", "max_stars_repo_head_hexsha": "39e062a34ce7d3bb693dceff0a7e68ea1ee6864b", "max_stars_repo_licenses": ["BSD-3-Clause-Clear"], "max_stars_count": 15.0, "max_stars_repo_stars_event_min_datetime": "2020-09-04T18:32:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T08:29:05.000Z", "max_issues_repo_path": "belatedly/src/belatedly.cpp", "max_issues_repo_name": "Ahziu/Delayed-Hits", "max_issues_repo_head_hexsha": "39e062a34ce7d3bb693dceff0a7e68ea1ee6864b", "max_issues_repo_licenses": ["BSD-3-Clause-Clear"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-02-18T08:14:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-18T08:14:29.000Z", "max_forks_repo_path": "belatedly/src/belatedly.cpp", "max_forks_repo_name": "Ahziu/Delayed-Hits", "max_forks_repo_head_hexsha": "39e062a34ce7d3bb693dceff0a7e68ea1ee6864b", "max_forks_repo_licenses": ["BSD-3-Clause-Clear"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-10-17T21:39:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-04T14:29:27.000Z", "avg_line_length": 40.3978494624, "max_line_length": 146, "alphanum_fraction": 0.599753188, "num_tokens": 9492, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7090191214879992, "lm_q2_score": 0.42250463481418826, "lm_q1q2_score": 0.29956386500056364}} {"text": "#pragma once\n#ifndef CANNON_RAY_MESH_H\n#define CANNON_RAY_MESH_H \n\n/*!\n * \\file cannon/ray/mesh.hpp\n * \\brief File containing TriangleMesh and Triangle class definitions.\n */\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n\n#include \n#include \n#include \n#include \n\nusing namespace Eigen;\n\nusing namespace cannon::log;\nusing namespace cannon::utils;\n\nnamespace cannon {\n namespace ray {\n\n using MatrixX3u = Matrix;\n using Vector3u = Matrix;\n\n CANNON_CLASS_FORWARD(HittableList);\n\n /*!\n * \\brief Class representing a mesh composed of a collection of triangles.\n */\n class TriangleMesh {\n public:\n\n TriangleMesh() = delete;\n \n /*! \n * Constructor taking object to world transform, vertices, normals,\n * texture coords, and face indices defining this mesh.\n */\n TriangleMesh(std::shared_ptr object_to_world,\n std::shared_ptr mat, const MatrixX3d& vertices, const\n MatrixX3d& normals, const MatrixX2d& tex_coords, const MatrixX3u&\n indices) : object_to_world_(object_to_world), mat_ptr_(mat),\n vertices_(vertices), normals_(normals), tex_coords_(tex_coords),\n indices_(indices) {\n\n // Transform all vertices and normals to world space to save on ray testing computation\n assert(vertices.rows() == normals.rows());\n\n for (unsigned int i = 0; i < vertices.rows(); i++) {\n vertices_.row(i) = (*object_to_world) * vertices.row(i).transpose();\n normals_.row(i) = object_to_world->linear() * normals.row(i).transpose();\n }\n }\n\n\n public:\n std::shared_ptr object_to_world_; //!< Object to world transform for this mesh\n std::shared_ptr mat_ptr_; //!< Material for this mesh\n\n MatrixX3d vertices_; //!< Vertices\n MatrixX3d normals_; //!< Normals\n MatrixX2d tex_coords_; //!< Texture coordinates (UV)\n MatrixX3u indices_; //!< Indices into vertices/normals for each face\n\n };\n\n /*!\n * \\brief Class representing a single triangle hittable.\n */\n class Triangle : public Hittable {\n public:\n\n Triangle() = delete;\n\n /*!\n * Constructor taking object_to_world transform, parent mesh, and face\n * index within mesh.\n */\n Triangle(std::shared_ptr object_to_world,\n std::shared_ptr mesh, int mesh_index) :\n Hittable(object_to_world), parent_mesh_(mesh),\n mesh_index_(mesh_index) {}\n\n /*!\n * Destructor.\n */\n virtual ~Triangle() {}\n \n /*!\n * Inherited from Hittable.\n */\n virtual bool bounding_box(double time_0, double time_1, Aabb& output_box) const override;\n\n /*!\n * Inherited from Hittable.\n */\n virtual bool object_space_bounding_box(double time_0, double time_1, Aabb& output_box) const override;\n\n /*!\n * Inherited from Hittable.\n */\n virtual bool hit(const Ray& r, double t_min, double t_max, hit_record& rec) const override;\n\n /*!\n * Inherited from Hittable.\n */\n virtual bool object_space_hit(const Ray& r, double t_min, double t_max, hit_record& rec) const override;\n\n public:\n std::shared_ptr parent_mesh_; //!< Mesh that this triangle is a part of\n int mesh_index_; //!< Index of this triangle in the parent mesh\n\n };\n\n // Public Functions\n \n /*!\n * Function to load a collection of meshes from an object file.\n *\n * \\param t Object-to-world transform for the loaded model.\n * \\param m Material for loaded model (not loading textures from file for now).\n * \\param path The file to load.\n *\n * \\returns A vector of meshes loaded from the file.\n */\n std::vector>\n load_model(std::shared_ptr t, std::shared_ptr m, const std::string& path);\n\n /*!\n * Function to process an Assimp model node into a list of meshes.\n *\n * \\param t Object-to-world transform for the loaded model.\n * \\param m Material for loaded model.\n * \\param node The node to process\n * \\param scene The overall Assimp scene\n * \n * \\returns A vector of meshes loaded from the node.\n */\n std::vector>\n process_model_node(std::shared_ptr t, std::shared_ptr m, aiNode *node, const\n aiScene *scene);\n\n /*!\n * Function to process a single Assimp mesh\n *\n * \\param t Object-to-world transform for the loaded model.\n * \\param m Material for loaded mesh\n * \\param mesh The mesh to process\n * \\param scene The overall Assimp scene\n *\n * \\returns The processed TriangleMesh\n */\n std::shared_ptr process_model_mesh(std::shared_ptr\n t, std::shared_ptr m, aiMesh *mesh, const aiScene *scene);\n\n /*!\n * Create list of hittable triangles for the input mesh.\n *\n * \\param mesh The triangle mesh to process into triangles\n *\n * \\returns The list of hittables.\n */\n HittableListPtr make_mesh_triangle_list(std::shared_ptr mesh);\n\n /*!\n * Permute the coordinates of an input vector.\n *\n * \\param p The vector to permute.\n * \\param x Index of new x coordinate in orginal vector.\n * \\param y Index of new y coordinate in orginal vector.\n * \\param z Index of new z coordinate in orginal vector.\n *\n * \\return The permuted vector.\n */\n Vector3d permute_vec(const Vector3d& p, int x, int y, int z);\n \n\n } // namespace ray\n} // namespace cannon\n\n#endif /* ifndef CANNON_RAY_MESH_H */\n", "meta": {"hexsha": "688710e631d8f2ecfd5ef2da41f90496b7a7e84c", "size": 6076, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cannon/ray/mesh.hpp", "max_stars_repo_name": "cannontwo/cannon", "max_stars_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cannon/ray/mesh.hpp", "max_issues_repo_name": "cannontwo/cannon", "max_issues_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 46.0, "max_issues_repo_issues_event_min_datetime": "2021-01-12T23:03:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-01T17:29:01.000Z", "max_forks_repo_path": "cannon/ray/mesh.hpp", "max_forks_repo_name": "cannontwo/cannon", "max_forks_repo_head_hexsha": "4be79f3a6200d1a3cd26c28c8f2250dbdf08f267", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.481865285, "max_line_length": 112, "alphanum_fraction": 0.6374259381, "num_tokens": 1439, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6723316860482763, "lm_q2_score": 0.4455295350395727, "lm_q1q2_score": 0.2995436234774605}} {"text": "/**************************************************************************\\\n|\n| Copyright (C) 2009 Marc Stevens\n|\n| This program is free software: you can redistribute it and/or modify\n| it under the terms of the GNU General Public License as published by\n| the Free Software Foundation, either version 3 of the License, or\n| (at your option) any later version.\n|\n| This program is distributed in the hope that it will be useful,\n| but WITHOUT ANY WARRANTY; without even the implied warranty of\n| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n| GNU General Public License for more details.\n|\n| You should have received a copy of the GNU General Public License\n| along with this program. If not, see .\n|\n\\**************************************************************************/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#define SHA1DETAIL_INLINE_IMPL\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \nusing namespace std;\nusing namespace hashclash;\n\n//#define FORCE_TEND 80\n//#define FORCE_TEND 27 // 24\n#define FORCE_TEND (20+1)\n\n#define BC_PREVR bc_or2\n#define BC_PREVRN bc_or2b\n\nvector maincase;\nvector okpaths;\nmap< sha1differentialpath, vector > okpaths_index;\n\n void show_path2(const sha1differentialpath& path, ostream& o = cout)\n {\n for (int t = path.tbegin(); t < path.tend(); ++t)\n {\n o << \"Q\" << t << \":\\t\" << path[t];\n if (t-4 >= path.tbegin() && t+1 < path.tend() && t >= 0 && t < 80)\n {\n o << path.getme(t);\n vector ambiguous, impossible;\n booleanfunction* F = 0;\n if (t < 20) F = & SHA1_F1_data;\n else if (t < 40) F = & SHA1_F2_data;\n else if (t < 60) F = & SHA1_F3_data;\n else F = & SHA1_F4_data;\n uint32 dF = 0;\n for (unsigned b = 0; b < 32; ++b)\n {\n bitcondition qtm3b = path(t-3,(b+2)&31); if (qtm3b == BC_PREVR || qtm3b == BC_PREVRN) qtm3b = bc_constant;\n bitcondition qtm2b = path(t-2,(b+2)&31); if (qtm2b == BC_PREVR || qtm2b == BC_PREVRN) qtm2b = bc_constant;\n bitcondition qtm1b = path(t-1,b); if (qtm1b == bc_prev || qtm1b == bc_prevn) qtm1b = bc_constant;\n if (qtm1b == BC_PREVR) qtm1b = bc_prev;\n else if (qtm1b == BC_PREVRN) qtm1b = bc_prevn;\n\t\t\t\t\t\n bf_outcome outcome = F->outcome(qtm1b, qtm2b, qtm3b);\n if (outcome.size() == 1) {\n if (outcome[0] == bc_plus) dF += 1< 0)\n {\n o << \" amb:\" << ambiguous[0];\n for (unsigned i = 1; i < ambiguous.size(); ++i)\n o << \",\" << ambiguous[i];\n }\n if (impossible.size() > 0)\n {\n o << \" imp:\" << impossible[0];\n for (unsigned i = 1; i < impossible.size(); ++i)\n o << \",\" << impossible[i];\n }\n } else \n o << sdr();\n o << endl;\n }\n }\n\nvoid cleanuppath2(sha1differentialpath& path)\n{\n sha1differentialpath newpath;\n for (int t = path.tbegin(); t < path.tend(); ++t) {\n if (t-4 >= path.tbegin() && t+1 < path.tend()) {\n newpath.getme(t) = path.getme(t);\n if (newpath.getme(t).get(31)!= 0)\n newpath.getme(t).sign |= 1<<31;\n }\n newpath[t] = path[t].getsdr();\n }\n for (int t = path.tend()-2; t-4 >= path.tbegin(); --t) {\n booleanfunction* F = 0;\n if (t < 20) F = & SHA1_F1_data;\n else if (t < 40) F = & SHA1_F2_data;\n else if (t < 60) F = & SHA1_F3_data;\n else F = & SHA1_F4_data;\n for (unsigned b = 0; b < 32; ++b) {\n bitcondition qtm3bo = path(t-3,(b+2)&31);\n bitcondition qtm2bo = path(t-2,(b+2)&31);\n bitcondition qtm1bo = path(t-1,b);\n bitcondition qtm3b = newpath(t-3,(b+2)&31); if (qtm3b == BC_PREVR || qtm3b == BC_PREVRN) qtm3b = bc_constant;\n bitcondition qtm2b = newpath(t-2,(b+2)&31); if (qtm2b == BC_PREVR || qtm2b == BC_PREVRN) qtm2b = bc_constant;\n bitcondition qtm1b = newpath(t-1,b); if (qtm1b == bc_prev || qtm1b == bc_prevn) qtm1b = bc_constant;\n if (qtm1b == BC_PREVR) qtm1b = bc_prev;\n else if (qtm1b == BC_PREVRN) qtm1b = bc_prevn;\n bf_outcome outcome_path = F->outcome(qtm1bo, qtm2bo, qtm3bo);\n if (outcome_path.size() != 1 && b < 31) {\n cerr << \"multiple outcome \" << t << \" \" << b << endl;\n show_path2(path);\n exit(0);\n }\n bf_outcome outcome = F->outcome(qtm1b, qtm2b, qtm3b);\n if (outcome.size() > 1 && b < 31) {\n bf_conditions newcond = F->backwardconditions(qtm1b, qtm2b, qtm3b, outcome_path[0]);\n if (newcond.first == bc_prev) newcond.first = BC_PREVR;\n if (newcond.first == bc_prevn) newcond.first = BC_PREVRN;\n newpath.setbitcondition(t-1,b,newcond.first);\n newpath.setbitcondition(t-2,(b+2)&31,newcond.second);\n newpath.setbitcondition(t-3,(b+2)&31,newcond.third);\n } else if (b == 31 && outcome.size() > 1 && outcome_path[0] == bc_constant) {\n bf_conditions newcond = F->backwardconditions(qtm1b, qtm2b, qtm3b, bc_constant);\n if (newcond.first == bc_prev) newcond.first = BC_PREVR;\n if (newcond.first == bc_prevn) newcond.first = BC_PREVRN;\n newpath.setbitcondition(t-1,b,newcond.first);\n newpath.setbitcondition(t-2,(b+2)&31,newcond.second);\n newpath.setbitcondition(t-3,(b+2)&31,newcond.third);\n } else if (b == 31 && outcome.size() > 1 && outcome_path[0] != bc_constant) {\n if (outcome.size() == 3) {\n // request dF[b] = 0\n bf_conditions newcond = F->backwardconditions(qtm1b, qtm2b, qtm3b, bc_constant);\n // invert addition bitconditions\n if (newcond.second == bc_prev) newcond.second = bc_prevn;\n if (newcond.first == bc_prev) newcond.first = BC_PREVR;\n if (newcond.first == bc_prevn) newcond.first = BC_PREVRN;\n newpath.setbitcondition(t-1,b,newcond.first);\n newpath.setbitcondition(t-2,(b+2)&31,newcond.second);\n newpath.setbitcondition(t-3,(b+2)&31,newcond.third);\n }\n }\n }\n }\n path = newpath; \n}\n\nvoid loadokpaths()\n{\n cout << \"Searching for files 'okpaths.*.bz2'...\" << endl;\n for (boost::filesystem::directory_iterator dit(\".\"); dit != boost::filesystem::directory_iterator(); ++dit)\n#if BOOST_VERSION == 104300\n if (dit->path().filename().substr(0,8) == \"okpaths.\" && dit->path().extension() == \".bz2\")\n#else\n if (dit->path().filename().string().substr(0,8) == \"okpaths.\" && dit->path().extension() == \".bz2\")\n#endif\n {\n#if BOOST_VERSION == 104300\n string file = dit->path().filename();\n#else\n string file = dit->path().filename().string();\n#endif\n cout << \"Loading '\" << file << \"'...\" << flush;\n vector tmp;\n for (unsigned trycnt = 0; tmp.size()==0 && trycnt < 2; ++trycnt) {\n try {\n load_bz2(tmp, text_archive, dit->path());\n } catch (std::exception& e) { \n cout << e.what() << endl; tmp.clear();\n boost::this_thread::sleep(boost::posix_time::milliseconds(100));\n }\n }\n okpaths.insert(okpaths.end(), tmp.begin(), tmp.end());\n cout << \"done: \" << tmp.size() << \" paths (new total: \" << okpaths.size() << \")\" << endl;\n }\n}\nvoid index_okpaths()\n{\n#if 1\n for (unsigned i = 0; i < okpaths.size(); ++i) {\n cleanuppath2(okpaths[i]);\n if (okpaths[i].tend() > FORCE_TEND) {\n okpaths[i].path.resize( okpaths[i].path.size() + FORCE_TEND - okpaths[i].tend() );\n okpaths[i].me.resize( okpaths[i].path.size() ); \n }\n okpaths_index[okpaths[i]].push_back(okpaths[i]);\n }\n#else\n for (unsigned i = 0; i < okpaths.size(); ++i) {\n sha1differentialpath tmp;\n for (int t = okpaths[i].tbegin(); t < okpaths[i].tend() && t < FORCE_TEND; ++t) {\n tmp[t] = okpaths[i][t].getsdr();\n \n if (t-4 >= okpaths[i].tbegin() && t+1 < okpaths[i].tend() && t+1 < FORCE_TEND) {\n tmp.getme(t) = okpaths[i].getme(t);\n sdr me = tmp.getme(t);\n if (me.mask & (1<<31)) me.sign |= 1<<31;\n tmp.getme(t) = me;\n }\n }\n if (okpaths[i].tend() > FORCE_TEND) {\n okpaths[i].path.resize( okpaths[i].path.size() + FORCE_TEND - okpaths[i].tend() );\n okpaths[i].me.resize( okpaths[i].path.size() ); \n }\n okpaths_index[tmp].push_back(okpaths[i]);\n }\n#endif\n cout << \"Total # cases: \" << okpaths_index.size() << endl;\n unsigned totalcasecnts = 0;\n vector casecnts;\n for (map< sha1differentialpath, vector >::const_iterator\n cit = okpaths_index.begin(); cit != okpaths_index.end(); ++cit)\n {\n totalcasecnts += cit->second.size();\n casecnts.push_back(cit->second.size());\n if (cit->second.size() > maincase.size())\n maincase = cit->second;\n }\n vector casecntsbu = casecnts;\n unsigned cumcasecnts = 0;\n while (double(cumcasecnts) < double(totalcasecnts)*1.0)\n {\n int highind = -1, highval = 0;\n for (unsigned i = 0; i < casecntsbu.size(); ++i)\n if (casecntsbu[i] > highval) { highind = i; highval = casecntsbu[i]; }\n if (highind == -1) throw;\n cumcasecnts += highval;\n casecntsbu[highind] = 0; \n }\n unsigned i = 0;\n for (map< sha1differentialpath, vector >::const_iterator\n cit = okpaths_index.begin(); cit != okpaths_index.end(); ++cit,++i)\n {\n if (casecntsbu[i] == 0) {\n cout << \"Case \" << i << \": # paths = \" << casecnts[i] << \" (\" << double(100*casecnts[i])/double(totalcasecnts) << \"%)\" << endl;\n show_path2(cit->second[0]);\n }\n }\n}\n\nvoid checkokpaths()\n{\n loadokpaths();\n index_okpaths();\n exit(0);\n}\n", "meta": {"hexsha": "8975017ca43df4b783f7052aac0f2b4208cae7b9", "size": 12871, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/sha1attackgenerator/checkokpaths.cpp", "max_stars_repo_name": "killua4564/hashclash", "max_stars_repo_head_hexsha": "f780f17ef579e4bb246f5c47f31765f665dab74f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 398.0, "max_stars_repo_stars_event_min_datetime": "2017-10-16T19:46:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T23:45:05.000Z", "max_issues_repo_path": "src/sha1attackgenerator/checkokpaths.cpp", "max_issues_repo_name": "killua4564/hashclash", "max_issues_repo_head_hexsha": "f780f17ef579e4bb246f5c47f31765f665dab74f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 10.0, "max_issues_repo_issues_event_min_datetime": "2019-10-23T08:14:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-10T09:33:44.000Z", "max_forks_repo_path": "src/sha1attackgenerator/checkokpaths.cpp", "max_forks_repo_name": "killua4564/hashclash", "max_forks_repo_head_hexsha": "f780f17ef579e4bb246f5c47f31765f665dab74f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 72.0, "max_forks_repo_forks_event_min_datetime": "2017-10-18T14:44:36.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T18:07:19.000Z", "avg_line_length": 46.2985611511, "max_line_length": 167, "alphanum_fraction": 0.4794499262, "num_tokens": 3344, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6723316860482762, "lm_q2_score": 0.44552953503957277, "lm_q1q2_score": 0.2995436234774605}} {"text": "//---------------------------------------------------------------------------//\n//!\n//! \\file MonteCarlo_SubshellIncoherentPhotonScatteringDistribution.cpp\n//! \\author Alex Robinson\n//! \\brief The subshell incoherent photon scattering distribution decl.\n//!\n//---------------------------------------------------------------------------//\n\n// Std Lib Includes\n#include \n\n// Boost Includes\n#include \n#include \n\n// FRENSIE Includes\n#include \"MonteCarlo_SubshellIncoherentPhotonScatteringDistribution.hpp\"\n#include \"MonteCarlo_PhotonKinematicsHelpers.hpp\"\n#include \"MonteCarlo_ElectronState.hpp\"\n#include \"Utility_PhysicalConstants.hpp\"\n#include \"Utility_RandomNumberGenerator.hpp\"\n#include \"Utility_GaussKronrodIntegrator.hpp\"\n#include \"Utility_ContractException.hpp\"\n\nnamespace MonteCarlo{\n\n// Constructor\n/*! \\details The occupation number grid must be in me*c units.\n */\nSubshellIncoherentPhotonScatteringDistribution::SubshellIncoherentPhotonScatteringDistribution(\n const SubshellType interaction_subshell,\n const double num_electrons_in_subshell,\n const double binding_energy,\n const Teuchos::RCP& occupation_number,\n const double kahn_sampling_cutoff_energy )\n : IncoherentPhotonScatteringDistribution( kahn_sampling_cutoff_energy ),\n d_subshell( interaction_subshell ),\n d_num_electrons_in_subshell( num_electrons_in_subshell ),\n d_binding_energy( binding_energy ),\n d_occupation_number( occupation_number )\n{\n // Make sure the interaction subshell is valid\n testPrecondition( interaction_subshell != INVALID_SUBSHELL );\n testPrecondition( interaction_subshell != UNKNOWN_SUBSHELL );\n // Make sure the number of electrons is valid\n testPrecondition( num_electrons_in_subshell > 0.0 );\n // Make sure the binding energy is valid\n testPrecondition( binding_energy > 0.0 );\n // Make sure the occupation number is valid\n testPrecondition( !occupation_number.is_null() );\n testPrecondition( occupation_number->getLowerBoundOfIndepVar() == -1.0 ); \n}\n\n\n// Return the subshell\nSubshellType \nSubshellIncoherentPhotonScatteringDistribution::getSubshell() const\n{\n return d_subshell;\n}\n\n// Return the number of electrons in the subshell\ndouble SubshellIncoherentPhotonScatteringDistribution::getNumberOfElectronsInSubshell() const\n{\n return d_num_electrons_in_subshell;\n}\n\n// Return the binding energy\ndouble SubshellIncoherentPhotonScatteringDistribution::getBindingEnergy() const\n{\n return d_binding_energy;\n}\n\n// Evaluate the distribution\ndouble SubshellIncoherentPhotonScatteringDistribution::evaluate( \n\t\t\t const double incoming_energy,\n\t\t\t const double scattering_angle_cosine ) const\n{\n // Make sure the incoming energy is valid\n testPrecondition( incoming_energy > d_binding_energy );\n // Make sure the scattering angle cosine is valid\n testPrecondition( scattering_angle_cosine >= -1.0 );\n testPrecondition( scattering_angle_cosine <= 1.0 );\n\n const double occupation_number = \n this->evaluateOccupationNumber( incoming_energy, scattering_angle_cosine );\n \n const double diff_kn_cross_section = \n this->evaluateKleinNishinaDist( incoming_energy,\n\t\t\t\t scattering_angle_cosine );\n\n return d_num_electrons_in_subshell*occupation_number*diff_kn_cross_section;\n}\n\n// Evaluate the integrated cross section (cm^2)\ndouble SubshellIncoherentPhotonScatteringDistribution::evaluateIntegratedCrossSection( \n\t\t\t\t\t\t const double incoming_energy,\n\t\t\t\t\t\t const double precision) const\n{\n // Make sure the incoming energy is valid\n testPrecondition( incoming_energy > d_binding_energy );\n\n // Evaluate the integrated cross section\n boost::function diff_cs_wrapper = \n boost::bind( &SubshellIncoherentPhotonScatteringDistribution::evaluate,\n\t\t\t boost::cref( *this ),\n\t\t\t incoming_energy,\n\t\t\t _1 );\n\n double abs_error, integrated_cs;\n\n Utility::GaussKronrodIntegrator quadrature_gkq_set( precision );\n\n quadrature_gkq_set.integrateAdaptively<15>( diff_cs_wrapper,\n\t\t\t\t\t -1.0,\n\t\t\t\t\t 1.0,\n\t\t\t\t\t integrated_cs,\n\t\t\t\t\t abs_error );\n\n // Make sure the integrated cross section is valid\n testPostcondition( integrated_cs > 0.0 );\n\n return integrated_cs;\n}\n\n// Sample an outgoing energy and direction from the distribution\n/*! \\details This function will only sample a Compton line energy (no\n * Doppler broadening).\n */ \nvoid SubshellIncoherentPhotonScatteringDistribution::sample( \n\t\t\t\t const double incoming_energy,\n\t\t\t\t double& outgoing_energy,\n\t\t\t\t double& scattering_angle_cosine ) const\n{\n // Make sure the incoming energy is valid\n testPrecondition( incoming_energy > d_binding_energy );\n\n unsigned trial_dummy;\n \n return this->sampleAndRecordTrials( incoming_energy,\n\t\t\t\t outgoing_energy,\n\t\t\t\t scattering_angle_cosine,\n\t\t\t\t trial_dummy );\n}\n\n// Sample an outgoing energy and direction and record the number of trials\n/*! \\details This function will only sample a Compton line energy (no\n * Doppler broadening).\n */ \nvoid SubshellIncoherentPhotonScatteringDistribution::sampleAndRecordTrials( \n\t\t\t\t\t const double incoming_energy,\n\t\t\t\t\t double& outgoing_energy,\n\t\t\t\t\t double& scattering_angle_cosine,\n\t\t\t\t\t unsigned& trials ) const\n{\n // Make sure the incoming energy is valid\n testPrecondition( incoming_energy > d_binding_energy );\n\n // Evaluate the maximum occupation number\n const double max_occupation_number = \n this->evaluateOccupationNumber( incoming_energy, -1.0 );\n\n while( true )\n {\n this->sampleAndRecordTrialsKleinNishina( incoming_energy,\n\t\t\t\t\t outgoing_energy,\n\t\t\t\t\t scattering_angle_cosine,\n\t\t\t\t\t trials );\n\n const double occupation_number = \n this->evaluateOccupationNumber( incoming_energy, \n\t\t\t\t scattering_angle_cosine );\n\n const double scaled_random_number = max_occupation_number*\n Utility::RandomNumberGenerator::getRandomNumber();\n\n if( scaled_random_number <= occupation_number )\n break;\n }\n\n // Make sure the scattering angle cosine is valid\n testPostcondition( scattering_angle_cosine >= -1.0 );\n testPostcondition( scattering_angle_cosine <= 1.0 );\n // Make sure the compton line energy is valid\n testPostcondition( outgoing_energy <= incoming_energy );\n remember( double alpha = incoming_energy/\n\t Utility::PhysicalConstants::electron_rest_mass_energy );\n testPostcondition( outgoing_energy >= incoming_energy/(1+2*alpha) );\n}\n\n// Evaluate the occupation number \ndouble \nSubshellIncoherentPhotonScatteringDistribution::evaluateOccupationNumber(\n\t\t\t\t const double incoming_energy,\n\t\t\t\t const double scattering_angle_cosine ) const\n{\n // Make sure the incoming energy is valid\n testPrecondition( incoming_energy >= d_binding_energy );\n // Make sure the scattering angle cosine is valid\n testPrecondition( scattering_angle_cosine >= -1.0 );\n testPrecondition( scattering_angle_cosine <= 1.0 );\n \n const double occupation_number_arg = \n this->calculateOccupationNumberArgument( incoming_energy,\n\t\t\t\t\t scattering_angle_cosine );\n\n return d_occupation_number->evaluate( occupation_number_arg );\n}\n\n// Calculate the occupation number argument (pz max)\ndouble SubshellIncoherentPhotonScatteringDistribution::calculateOccupationNumberArgument(\n\t\t\t\t const double incoming_energy,\n\t\t\t\t const double scattering_angle_cosine ) const\n{\n // Make sure the incoming energy is valid\n testPrecondition( incoming_energy >= d_binding_energy );\n // Make sure the scattering angle cosine is valid\n testPrecondition( scattering_angle_cosine >= -1.0 );\n testPrecondition( scattering_angle_cosine <= 1.0 );\n\n double occupation_number_arg = \n calculateMaxElectronMomentumProjection( incoming_energy,\n\t\t\t\t\t d_binding_energy,\n\t\t\t\t\t scattering_angle_cosine );\n\n if( occupation_number_arg >= d_occupation_number->getUpperBoundOfIndepVar() )\n occupation_number_arg = d_occupation_number->getUpperBoundOfIndepVar();\n\n // Make sure the occupation number arg is valid\n testPostcondition( occupation_number_arg >= \n\t\t d_occupation_number->getLowerBoundOfIndepVar() );\n testPostcondition( occupation_number_arg <=\n\t\t d_occupation_number->getUpperBoundOfIndepVar() );\n\n return occupation_number_arg;\n}\n\n// Randomly scatter the photon\n/*! \\details The particle bank is used to store the electron that is emitted\n * from the collision. Whether or not Doppler broadening is done, the \n * energy and direction of the outgoing electron is calculated as if it were\n * at rest initially (feel free to update this model!).\n */\nvoid SubshellIncoherentPhotonScatteringDistribution::scatterPhoton( \n\t\t\t\t PhotonState& photon,\n\t\t\t\t ParticleBank& bank,\n\t\t\t\t SubshellType& shell_of_interaction ) const\n{\n // Make sure the photon energy is valid\n testPrecondition( photon.getEnergy() > d_binding_energy );\n\n double outgoing_energy, scattering_angle_cosine;\n\n // Sample an outgoing energy and direction\n this->sample( photon.getEnergy(),\n\t\toutgoing_energy,\n\t\tscattering_angle_cosine );\n\n // Set the interaction subshell\n shell_of_interaction = d_subshell;\n\n // Sample the azimuthal angle of the outgoing photon\n const double azimuthal_angle = this->sampleAzimuthalAngle();\n\n // Create the ejectected electron\n this->createEjectedElectron( photon, \n\t\t\t scattering_angle_cosine, \n\t\t\t azimuthal_angle,\n\t\t\t bank );\n \n // Set the new energy\n if( outgoing_energy > 0.0 )\n {\n photon.setEnergy( outgoing_energy );\n \n // Set the new direction\n photon.rotateDirection( scattering_angle_cosine, azimuthal_angle );\n }\n else\n {\n photon.setEnergy( std::numeric_limits::min() );\n\n photon.setAsGone();\n }\n}\n \n} // end MonteCarlo namespace\n\n//---------------------------------------------------------------------------//\n// end MonteCarlo_SubshellIncoherentPhotonScatteringDistribution.cpp\n//---------------------------------------------------------------------------//\n", "meta": {"hexsha": "e67cbcd35cf891dd7ff29f5aa79d4b6a47b9cd41", "size": 9988, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "packages/monte_carlo/collision/native/src/MonteCarlo_SubshellIncoherentPhotonScatteringDistribution.cpp", "max_stars_repo_name": "lkersting/SCR-2123", "max_stars_repo_head_hexsha": "06ae3d92998664a520dc6a271809a5aeffe18f72", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "packages/monte_carlo/collision/native/src/MonteCarlo_SubshellIncoherentPhotonScatteringDistribution.cpp", "max_issues_repo_name": "lkersting/SCR-2123", "max_issues_repo_head_hexsha": "06ae3d92998664a520dc6a271809a5aeffe18f72", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "packages/monte_carlo/collision/native/src/MonteCarlo_SubshellIncoherentPhotonScatteringDistribution.cpp", "max_forks_repo_name": "lkersting/SCR-2123", "max_forks_repo_head_hexsha": "06ae3d92998664a520dc6a271809a5aeffe18f72", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.2054794521, "max_line_length": 95, "alphanum_fraction": 0.7338806568, "num_tokens": 2176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.29954279967694514}} {"text": "/**\n * Copyright (c) 2020 libnuls developers (see AUTHORS)\n *\n * This file is part of libnuls.\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Affero General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Affero General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with this program. If not, see .\n */\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"../math/external/lax_der_parsing.h\"\n#include \"secp256k1_initializer.hpp\"\n\nnamespace libnuls {\nnamespace system {\n\nusing namespace boost;\n\nstatic constexpr uint8_t compressed_even = 0x02;\nstatic constexpr uint8_t compressed_odd = 0x03;\nstatic constexpr uint8_t uncompressed = 0x04;\n\nBC_CONSTFUNC int to_flags(bool compressed)\n{\n return compressed ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED;\n}\n\n// Helper templates\n// ----------------------------------------------------------------------------\n// These allow strong typing of private keys without redundant code.\n\ntemplate \nbool parse(const secp256k1_context* context, secp256k1_pubkey& out,\n const byte_array& point)\n{\n return secp256k1_ec_pubkey_parse(context, &out, point.data(), Size) == 1;\n}\n\ntemplate \nbool serialize(const secp256k1_context* context, byte_array& out,\n const secp256k1_pubkey point)\n{\n auto size = Size;\n const auto flags = to_flags(Size == ec_compressed_size);\n secp256k1_ec_pubkey_serialize(context, out.data(), &size, &point, flags);\n return size == Size;\n}\n\ntemplate \nbool ec_add(const secp256k1_context* context, byte_array& in_out,\n const ec_secret& secret)\n{\n secp256k1_pubkey pubkey;\n return parse(context, pubkey, in_out) &&\n secp256k1_ec_pubkey_tweak_add(context, &pubkey, secret.data()) == 1 &&\n serialize(context, in_out, pubkey);\n}\n\ntemplate \nbool ec_multiply(const secp256k1_context* context, byte_array& in_out,\n const ec_secret& secret)\n{\n secp256k1_pubkey pubkey;\n return parse(context, pubkey, in_out) &&\n secp256k1_ec_pubkey_tweak_mul(context, &pubkey, secret.data()) == 1 &&\n serialize(context, in_out, pubkey);\n}\n\ntemplate \nbool ec_negate(const secp256k1_context* context, byte_array& in_out)\n{\n secp256k1_pubkey pubkey;\n return parse(context, pubkey, in_out) &&\n secp256k1_ec_pubkey_negate(context, &pubkey) == 1 &&\n serialize(context, in_out, pubkey);\n}\n\ntemplate \nbool secret_to_public(const secp256k1_context* context, byte_array& out,\n const ec_secret& secret)\n{\n secp256k1_pubkey pubkey;\n return secp256k1_ec_pubkey_create(context, &pubkey, secret.data()) == 1 &&\n serialize(context, out, pubkey);\n}\n\ntemplate \nbool recover_public(const secp256k1_context* context, byte_array& out,\n const recoverable_signature& recoverable, const hash_digest& hash)\n{\n secp256k1_pubkey pubkey;\n secp256k1_ecdsa_recoverable_signature sign;\n const auto recovery_id = safe_to_signed(recoverable.recovery_id);\n return\n secp256k1_ecdsa_recoverable_signature_parse_compact(context,\n &sign, recoverable.signature.data(), recovery_id) == 1 &&\n secp256k1_ecdsa_recover(context, &pubkey, &sign, hash.data()) == 1 &&\n serialize(context, out, pubkey);\n}\n\nbool verify_signature(const secp256k1_context* context,\n const secp256k1_pubkey point, const hash_digest& hash,\n const ec_signature& signature)\n{\n // Copy to avoid exposing external types.\n secp256k1_ecdsa_signature parsed;\n std::copy_n(signature.begin(), ec_signature_size, std::begin(parsed.data));\n\n // secp256k1_ecdsa_verify rejects non-normalized (low-s) signatures, but\n // bitcoin does not have such a limitation, so we always normalize.\n secp256k1_ecdsa_signature normal;\n secp256k1_ecdsa_signature_normalize(context, &normal, &parsed);\n return secp256k1_ecdsa_verify(context, &normal, hash.data(), &point) == 1;\n}\n\n// Add and multiply EC values\n// ----------------------------------------------------------------------------\n\nbool ec_add(ec_compressed& point, const ec_secret& scalar)\n{\n const auto context = verification.context();\n return ec_add(context, point, scalar);\n}\n\nbool ec_add(ec_uncompressed& point, const ec_secret& scalar)\n{\n const auto context = verification.context();\n return ec_add(context, point, scalar);\n}\n\nbool ec_add(ec_secret& left, const ec_secret& right)\n{\n const auto context = verification.context();\n return secp256k1_ec_privkey_tweak_add(context, left.data(),\n right.data()) == 1;\n}\n\nbool ec_multiply(ec_compressed& point, const ec_secret& scalar)\n{\n const auto context = verification.context();\n return ec_multiply(context, point, scalar);\n}\n\nbool ec_multiply(ec_uncompressed& point, const ec_secret& scalar)\n{\n const auto context = verification.context();\n return ec_multiply(context, point, scalar);\n}\n\nbool ec_multiply(ec_secret& left, const ec_secret& right)\n{\n const auto context = verification.context();\n return secp256k1_ec_privkey_tweak_mul(context, left.data(),\n right.data()) == 1;\n}\n\nbool ec_negate(ec_secret& scalar)\n{\n const auto context = verification.context();\n return secp256k1_ec_privkey_negate(context, scalar.data()) == 1;\n}\n\nbool ec_negate(ec_compressed& point)\n{\n const auto context = verification.context();\n return ec_negate(context, point);\n}\n\nbool ec_sum(ec_compressed& result, const point_list& points)\n{\n secp256k1_pubkey pubkey;\n ptr_vector keys(points.size());\n const auto context = verification.context();\n\n for (const auto& point: points)\n {\n keys.push_back(new secp256k1_pubkey);\n if (!parse(context, keys.back(), point))\n return false;\n }\n\n return secp256k1_ec_pubkey_combine(context, &pubkey, keys.c_array(),\n points.size()) == 1 && serialize(context, result, pubkey);\n}\n\n// Convert keys\n// ----------------------------------------------------------------------------\n\nbool compress(ec_compressed& out, const ec_uncompressed& point)\n{\n secp256k1_pubkey pubkey;\n const auto context = verification.context();\n return parse(context, pubkey, point) && serialize(context, out, pubkey);\n}\n\nbool decompress(ec_uncompressed& out, const ec_compressed& point)\n{\n secp256k1_pubkey pubkey;\n const auto context = verification.context();\n return parse(context, pubkey, point) && serialize(context, out, pubkey);\n}\n\nbool secret_to_public(ec_compressed& out, const ec_secret& secret)\n{\n const auto context = signing.context();\n return secret_to_public(context, out, secret);\n}\n\nbool secret_to_public(ec_uncompressed& out, const ec_secret& secret)\n{\n const auto context = signing.context();\n return secret_to_public(context, out, secret);\n}\n\n// Verify keys\n// ----------------------------------------------------------------------------\n\nbool verify(const ec_secret& secret)\n{\n const auto context = verification.context();\n return secp256k1_ec_seckey_verify(context, secret.data()) == 1;\n}\n\nbool verify(const ec_compressed& point)\n{\n secp256k1_pubkey pubkey;\n const auto context = verification.context();\n return parse(context, pubkey, point);\n}\n\nbool verify(const ec_uncompressed& point)\n{\n secp256k1_pubkey pubkey;\n const auto context = verification.context();\n return parse(context, pubkey, point);\n}\n\n// Detect public keys\n// ----------------------------------------------------------------------------\n\nbool is_compressed_key(const data_slice& point)\n{\n const auto size = point.size();\n if (size != ec_compressed_size)\n return false;\n\n const auto first = point.data()[0];\n return first == compressed_even || first == compressed_odd;\n}\n\nbool is_uncompressed_key(const data_slice& point)\n{\n const auto size = point.size();\n if (size != ec_uncompressed_size)\n return false;\n\n const auto first = point.data()[0];\n return first == uncompressed;\n}\n\nbool is_public_key(const data_slice& point)\n{\n return is_compressed_key(point) || is_uncompressed_key(point);\n}\n\nbool is_even_key(const ec_compressed& point)\n{\n return point.front() == ec_even_sign;\n}\n\nbool is_endorsement(const endorsement& endorsement)\n{\n const auto size = endorsement.size();\n return size >= min_endorsement_size && size <= max_endorsement_size;\n}\n\n// DER parse/encode\n// ----------------------------------------------------------------------------\n\nbool parse_endorsement(uint8_t& sighash_type, der_signature& der_signature,\n const endorsement& endorsement)\n{\n if (endorsement.empty())\n return false;\n\n sighash_type = endorsement.back();\n der_signature = { endorsement.begin(), endorsement.end() - 1 };\n return true;\n}\n\nbool parse_signature(ec_signature& out, const der_signature& der_signature,\n bool strict)\n{\n if (der_signature.empty())\n return false;\n\n bool valid;\n secp256k1_ecdsa_signature parsed;\n const auto context = verification.context();\n\n if (strict)\n valid = secp256k1_ecdsa_signature_parse_der(context, &parsed,\n der_signature.data(), der_signature.size()) == 1;\n else\n valid = ecdsa_signature_parse_der_lax(context, &parsed,\n der_signature.data(), der_signature.size()) == 1;\n\n if (valid)\n std::copy_n(std::begin(parsed.data), ec_signature_size, out.begin());\n\n return valid;\n}\n\nbool encode_signature(der_signature& out, const ec_signature& signature)\n{\n // Copy to avoid exposing external types.\n secp256k1_ecdsa_signature sign;\n std::copy_n(signature.begin(), ec_signature_size, std::begin(sign.data));\n\n const auto context = signing.context();\n auto size = max_der_signature_size;\n out.resize(size);\n\n if (secp256k1_ecdsa_signature_serialize_der(context, out.data(), &size,\n &sign) != 1)\n return false;\n\n out.resize(size);\n return true;\n}\n\n// EC sign/verify\n// ----------------------------------------------------------------------------\n\nbool sign(ec_signature& out, const ec_secret& secret, const hash_digest& hash)\n{\n secp256k1_ecdsa_signature signature;\n const auto context = signing.context();\n\n if (secp256k1_ecdsa_sign(context, &signature, hash.data(), secret.data(),\n secp256k1_nonce_function_rfc6979, nullptr) != 1)\n return false;\n\n std::copy_n(std::begin(signature.data), out.size(), out.begin());\n return true;\n}\n\nbool verify_signature(const ec_compressed& point, const hash_digest& hash,\n const ec_signature& signature)\n{\n secp256k1_pubkey pubkey;\n const auto context = verification.context();\n return parse(context, pubkey, point) &&\n verify_signature(context, pubkey, hash, signature);\n}\n\nbool verify_signature(const ec_uncompressed& point, const hash_digest& hash,\n const ec_signature& signature)\n{\n secp256k1_pubkey pubkey;\n const auto context = verification.context();\n return parse(context, pubkey, point) &&\n verify_signature(context, pubkey, hash, signature);\n}\n\nbool verify_signature(const data_slice& point, const hash_digest& hash,\n const ec_signature& signature)\n{\n // Copy to avoid exposing external types.\n secp256k1_ecdsa_signature parsed;\n std::copy_n(signature.begin(), ec_signature_size, std::begin(parsed.data));\n\n // secp256k1_ecdsa_verify rejects non-normalized (low-s) signatures, but\n // bitcoin does not have such a limitation, so we always normalize.\n secp256k1_ecdsa_signature normal;\n const auto context = verification.context();\n secp256k1_ecdsa_signature_normalize(context, &normal, &parsed);\n\n // This uses a data slice and calls secp256k1_ec_pubkey_parse() in place of\n // parse() so that we can support the der_verify data_chunk optimization.\n secp256k1_pubkey pubkey;\n const auto size = point.size();\n return\n secp256k1_ec_pubkey_parse(context, &pubkey, point.data(), size) == 1 &&\n secp256k1_ecdsa_verify(context, &normal, hash.data(), &pubkey) == 1;\n}\n\n// Recoverable sign/recover\n// ----------------------------------------------------------------------------\n\nbool sign_recoverable(recoverable_signature& out, const ec_secret& secret,\n const hash_digest& hash)\n{\n int recovery_id = 0;\n const auto context = signing.context();\n secp256k1_ecdsa_recoverable_signature signature;\n\n const auto result =\n secp256k1_ecdsa_sign_recoverable(context, &signature, hash.data(),\n secret.data(), secp256k1_nonce_function_rfc6979, nullptr) == 1 &&\n secp256k1_ecdsa_recoverable_signature_serialize_compact(context,\n out.signature.data(), &recovery_id, &signature) == 1;\n\n BITCOIN_ASSERT(recovery_id >= 0 && recovery_id <= 3);\n out.recovery_id = safe_to_unsigned(recovery_id);\n return result;\n}\n\nbool recover_public(ec_compressed& out,\n const recoverable_signature& recoverable, const hash_digest& hash)\n{\n const auto context = verification.context();\n return recover_public(context, out, recoverable, hash);\n}\n\nbool recover_public(ec_uncompressed& out,\n const recoverable_signature& recoverable, const hash_digest& hash)\n{\n const auto context = verification.context();\n return recover_public(context, out, recoverable, hash);\n}\n\n} // namespace system\n} // namespace libnuls\n", "meta": {"hexsha": "3b8f8d81cdb0197062189402a5bdab57cb90f233", "size": 14072, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/math/elliptic_curve.cpp", "max_stars_repo_name": "ccccbjcn/nuls-v2-cplusplus-sdk", "max_stars_repo_head_hexsha": "3d5a76452fe0673eba490b26e5a95fea3d5788df", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-04-26T07:32:52.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-26T07:32:52.000Z", "max_issues_repo_path": "src/math/elliptic_curve.cpp", "max_issues_repo_name": "CCC-NULS/nuls-cplusplus-sdk", "max_issues_repo_head_hexsha": "3d5a76452fe0673eba490b26e5a95fea3d5788df", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/math/elliptic_curve.cpp", "max_forks_repo_name": "CCC-NULS/nuls-cplusplus-sdk", "max_forks_repo_head_hexsha": "3d5a76452fe0673eba490b26e5a95fea3d5788df", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.6224719101, "max_line_length": 79, "alphanum_fraction": 0.6890278567, "num_tokens": 3297, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.4263215925474903, "lm_q1q2_score": 0.2995037328812037}} {"text": "//\n// Created by Nathan on 7/10/2015.\n//\n\n#include \"world/PlainsCell.h\"\n#include \"world/DesertCell.h\"\n#include \"world/ForestCell.h\"\n#include \"game/Civilian.h\"\n#include \"game/generation/ClusterSeederV2.h\"\n#include \n#include \n#include \n\n\nnamespace undocked {\n namespace game {\n namespace generation {\n numeric::Random random(10);\n\n using namespace world;\n\n ClusterSeederV2::ClusterSeederV2() {\n\n }\n\n ClusterSeederV2::~ClusterSeederV2() {\n\n }\n\n void ClusterSeederV2::seedTerrain(GameState *state) {\n std::cout << \"Seeding terrain!\" << std::endl;\n CellularBoard *board = state->getBoard();\n int width = board->getWidth(), height = board->getHeight();\n\n\n std::vector anchors;\n boost::multi_array closestAnchors(boost::extents[height][width]);\n\n std::vector desertAnchors;\n boost::multi_array closestDesertAnchors(boost::extents[height][width]);\n\n\n // fill in with the default: PlainsCell\n for (int v = 0; v < height; v++) {\n for (int u = 0; u < width; u++) {\n board->setCell(u, v, PlainsCell());\n }\n }\n\n // seed clusters of desert\n int dcc = 1 + (random.get() > 0.5 ? 0 : 1);\n\n auto widthGen = random.createUniformInteger(3, 7);\n for (int i = 0; i < dcc; i++) {\n int cw = widthGen();\n int ch = widthGen();\n\n random.setUniform(0, width - cw - 1);\n int tu = random.getUniformInteger();\n\n random.setUniform(0, width - ch - 1);\n int tv = random.getUniformInteger();\n\n int cx = tu + cw / 2;\n int cy = tv + ch / 2;\n AnchorPoint *current = new AnchorPoint(sf::Vector2f(cx, cy));\n\n desertAnchors.push_back(current);\n\n for (int u = tu; u < tu + cw; u++) {\n for (int v = tv; v < tv + ch; v++) {\n if (random.get() < 0.8)\n board->setCell(u, v, DesertCell());\n }\n }\n }\n\n // seed clusters of forest\n random.setUniform(2, 6);\n int fcc = random.getUniformInteger();\n\n for (int i = 0; i < fcc; i++) {\n int cw = widthGen();\n int ch = widthGen();\n random.setUniform(0, width - cw - 1);\n int tu = random.getUniformInteger();\n\n random.setUniform(0, width - ch - 1);\n int tv = random.getUniformInteger();\n\n int cx = tu + cw / 2;\n int cy = tv + ch / 2;\n AnchorPoint *current = new AnchorPoint(sf::Vector2f(cx, cy));\n\n anchors.push_back(current);\n\n for (int u = tu; u < tu + cw; u++) {\n for (int v = tv; v < tv + ch; v++) {\n if (random.get() < 0.8)\n board->setCell(u, v, ForestCell());\n }\n }\n }\n\n std::cout << \"Calculating Anchor points!\" << std::endl;\n for (int v = 0; v < height; v++) {\n for (int u = 0; u < width; u++) {\n AnchorPoint *closest = nullptr;\n double minDist = 999999;\n for (auto anchor : anchors) {\n double dist = std::abs(anchor->location.x - u) + std::abs(anchor->location.y - v);\n if (dist < minDist) {\n closest = anchor;\n minDist = dist;\n }\n }\n\n closestAnchors[v][u] = closest;\n }\n }\n\n\n for (int v = 0; v < height; v++) {\n for (int u = 0; u < width; u++) {\n AnchorPoint *closest = nullptr;\n double minDist = 999999;\n for (auto anchor : desertAnchors) {\n double dist = std::abs(anchor->location.x - u) + std::abs(anchor->location.y - v);\n if (dist < minDist) {\n closest = anchor;\n minDist = dist;\n }\n }\n closestDesertAnchors[v][u] = closest;\n }\n }\n\n\n std::cout << \"Propagating terrain...\" << std::endl;\n // propagate the desert and forest terrains\n int iterations = (int) ceil((sqrt(width * height) / 40) * 6) * 3;\n int ruleSet = 0;\n for (int iteration = 0; iteration < iterations; iteration++) {\n std::cout << \"\\tIteration \" << iteration << \" / \" << iterations - 1 << std::endl;\n boost::multi_array, 2> neighbors(boost::extents[height][width]);\n\n for (int v = 0; v < height; v++) {\n for (int u = 0; u < width; u++) {\n int right = (u + 1);\n int up = (v + 1);\n int down = v - 1;\n int left = u - 1;\n int d_incident = 0, f_incident = 0;\n\n auto in = [height, width](int a, bool isUp) {\n if (isUp) {\n return a >= 0 && a < height;\n } else {\n return a >= 0 && a < width;\n }\n };\n\n if (in(right, 0) && board->getCell(right, v).getType() == BoardCell::TYPE::Desert) {\n d_incident += 1;\n }\n else if (in(right, 0) && board->getCell(right, v).getType() == BoardCell::TYPE::Forest) {\n f_incident += 1;\n }\n\n if (in(left, 0) && board->getCell(left, v).getType() == BoardCell::TYPE::Desert) {\n d_incident += 1;\n }\n else if (in(left, 0) && board->getCell(left, v).getType() == BoardCell::TYPE::Forest) {\n f_incident += 1;\n }\n\n if (in(up, 1) && board->getCell(u, up).getType() == BoardCell::TYPE::Desert) {\n d_incident += 1;\n }\n else if (in(up, 1) && board->getCell(u, up).getType() == BoardCell::TYPE::Forest) {\n f_incident += 1;\n }\n\n if (in(down, 1) && board->getCell(u, down).getType() == BoardCell::TYPE::Desert) {\n d_incident += 1;\n }\n else if (in(down, 1) && board->getCell(u, down).getType() == BoardCell::TYPE::Forest) {\n f_incident += 1;\n }\n\n neighbors[v][u] = std::make_pair(d_incident, f_incident);\n }\n }\n\n\n if ((iteration % 8) == 0) ruleSet = !ruleSet;\n\n if (ruleSet == 0) {\n for (int v = 0; v < height; v++) {\n for (int u = 0; u < width; u++) {\n BoardCell cell = board->getCell(u, v);\n std::pair pair = (std::pair) neighbors[v][u];\n int d_count = pair.first;\n int f_count = pair.second;\n\n if (cell.getType() == BoardCell::TYPE::Desert) {\n if (d_count == 1) {\n if (random.get() < 0)\n board->setCell(u, v, PlainsCell());\n\n }\n else if (d_count == 0) {\n board->setCell(u, v, PlainsCell());\n }\n }\n else if (cell.getType() == BoardCell::TYPE::Plains) {\n AnchorPoint *p = closestAnchors[v][u];\n AnchorPoint *dp = closestDesertAnchors[v][u];\n if (d_count > 1 && dp->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1)\n board->setCell(u, v, DesertCell());\n else if (d_count > 0 && dp->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1 && random.get() > 0.5) {\n board->setCell(u, v, DesertCell());\n }\n else if (f_count > 1 && p->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1) {\n board->setCell(u, v, ForestCell());\n }\n else if (f_count > 0 && p->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1 && random.get() > 0.5) {\n board->setCell(u, v, ForestCell());\n }\n\n }\n else if (cell.getType() == BoardCell::TYPE::Forest) {\n if (d_count > 0)\n board->setCell(u, v, PlainsCell());\n else if (f_count == 1 && random.get() > 0.9)\n board->setCell(u, v, PlainsCell());\n else if (f_count == 0 && random.get() > 0.5)\n board->setCell(u, v, PlainsCell());\n }\n }\n }\n } else {\n for (int v = 0; v < height; v++) {\n for (int u = 0; u < width; u++) {\n BoardCell cell = board->getCell(u, v);\n std::pair pair = (std::pair) neighbors[v][u];\n int d_count = pair.first;\n int f_count = pair.second;\n\n if (cell.getType() == BoardCell::TYPE::Desert) {\n if (d_count == 1) {\n if (random.get() < 0.5)\n board->setCell(u, v, PlainsCell());\n }\n else if (d_count == 0) {\n board->setCell(u, v, PlainsCell());\n }\n }\n else if (cell.getType() == BoardCell::TYPE::Plains) {\n AnchorPoint *p = closestAnchors[v][u];\n AnchorPoint *dp = closestDesertAnchors[v][u];\n if (d_count > 1 && dp->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1)\n board->setCell(u, v, DesertCell());\n else if (d_count > 0 && dp->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1 && random.get() > 0.5) {\n board->setCell(u, v, DesertCell());\n }\n else if (f_count > 1 && p->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1) {\n board->setCell(u, v, ForestCell());\n }\n else if (f_count > 0 && p->getComponent(sf::Vector2f(u, v)) > random.get() + 0.1 && random.get() > 0.5) {\n board->setCell(u, v, ForestCell());\n }\n\n }\n else if (cell.getType() == BoardCell::TYPE::Forest) {\n if (d_count > 0)\n board->setCell(u, v, PlainsCell());\n else if (f_count == 1 && random.get() > 0.7)\n board->setCell(u, v, PlainsCell());\n else if (f_count == 0 && random.get() > 0.4)\n board->setCell(u, v, PlainsCell());\n }\n }\n }\n }\n }\n\n board->generateAdjacencyGraph();\n\n // clean up\n for (auto anchor : desertAnchors) {\n delete anchor;\n }\n\n for (auto anchor : anchors) {\n delete anchor;\n }\n }\n\n void ClusterSeederV2::seedInfrastructure(GameState *state) {\n\n }\n\n void ClusterSeederV2::seedUnits(GameState *state) {\n int width = state->getBoard()->getWidth(),\n height = state->getBoard()->getHeight();\n\n auto widthGen = random.createUniformInteger(4, 8);\n int cw = widthGen();\n int ch = widthGen();\n\n int tu = random.createUniformInteger(0, width - cw - 1)();\n int tv = random.createUniformInteger(0, height - ch - 1)();\n\n std::vector locations((unsigned) cw * ch);\n std::iota(locations.begin(), locations.end(), 0);\n\n // random_shuffle should not be used, as it utilized rand()\n std::random_shuffle(locations.begin(), locations.end());\n\n for (int i = 0; i < 10; i++) {\n Civilian *civvie = new Civilian();\n int u = tu + locations[i] % cw,\n v = tv + locations[i] / cw;\n civvie->setLocation(sf::Vector2i(u, v));\n state->units.push_back(civvie);\n }\n\n std::sort(state->units.begin(), state->units.end(), [](Unit* a, Unit* b) {\n return a->getLocation().y < b->getLocation().y;\n });\n }\n\n double ClusterSeederV2::AnchorPoint::getComponent(sf::Vector2f loc) {\n sf::Vector2f displacement = loc - this->location;\n double theta = std::atan2(displacement.y, displacement.x);\n double num = func(theta) / 3.5;\n return std::min(num, 1);\n }\n\n double ClusterSeederV2::AnchorPoint::dSigmoid(double x) {\n return std::exp(x) / ((1 + std::exp(x)) * (1 + std::exp(x)));\n }\n\n double ClusterSeederV2::AnchorPoint::func(double theta) {\n double value1 = 1, value2 = 1;\n double PI = boost::math::constants::pi();\n\n for (auto pair : sizesAndPhases) {\n double size = pair.first;\n double phase = pair.second;\n\n // warning: some kind of wrapping will be needed for this!\n // this might explain some of the harsh edges seen; however this is a minor problem\n value1 += size * dSigmoid(10 * (theta - phase));\n value2 += size * dSigmoid(10 * (theta - 2 * PI - phase));\n }\n\n // two values in case a sigmoid function borders PI or -PI\n return std::abs(value1) > std::abs(value2) ? value1 : value2;\n }\n\n ClusterSeederV2::AnchorPoint::AnchorPoint(sf::Vector2f location) : location(location) {\n double PI = boost::math::constants::pi();\n\n auto sizeGen = random.createUniformDouble(-0.5, 12);\n auto phaseGen = random.createUniformDouble(-PI, PI);\n\n for (int i = 0; i < 10; i++) {\n sizesAndPhases.push_back(std::make_pair(sizeGen(), phaseGen()));\n }\n }\n\n }\n }\n}", "meta": {"hexsha": "70df5d09bf5afff7eccbcb13a15ed4b4911e4ba6", "size": 17125, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/game/generation/ClusterSeederV2.cpp", "max_stars_repo_name": "ciscprocess/pe-econ-sim", "max_stars_repo_head_hexsha": "0d33507a451aace0d8157b45c29bfc582e6b3c18", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/game/generation/ClusterSeederV2.cpp", "max_issues_repo_name": "ciscprocess/pe-econ-sim", "max_issues_repo_head_hexsha": "0d33507a451aace0d8157b45c29bfc582e6b3c18", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2015-07-14T02:30:37.000Z", "max_issues_repo_issues_event_max_datetime": "2015-07-26T22:11:28.000Z", "max_forks_repo_path": "src/game/generation/ClusterSeederV2.cpp", "max_forks_repo_name": "ciscprocess/pe-econ-sim", "max_forks_repo_head_hexsha": "0d33507a451aace0d8157b45c29bfc582e6b3c18", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.545212766, "max_line_length": 142, "alphanum_fraction": 0.3751240876, "num_tokens": 3474, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.4263215925474903, "lm_q1q2_score": 0.2995037328812037}} {"text": "/*\n* TS Elements\n* Copyright 2015-2018 M. Newhouse\n* Released under the MIT license.\n*/\n\n#include \"handling_v2.hpp\"\n#include \"car.hpp\"\n#include \"world.hpp\"\n\n#include \"resources/terrain_definition.hpp\"\n\n#include \"utility/transform.hpp\"\n#include \"utility/interpolate.hpp\"\n#include \"utility/math_utilities.hpp\"\n\n#include \n\n#include \n#include \n\n\nnamespace ts\n{\n namespace world\n {\n HandlingState update_car_state(Car& car, const World& world, double frame_duration)\n {\n auto& handling = car.handling();\n\n using controls::Control;\n auto half_wheelbase = handling.wheelbase_length * 0.5;\n\n std::array front_wheel_positions =\n { {\n { 0.0, -half_wheelbase + handling.wheelbase_offset }\n } };\n\n std::array rear_wheel_positions =\n { {\n { 0.0, half_wheelbase + handling.wheelbase_offset }\n } };\n\n if (handling.num_front_wheels >= 2)\n {\n front_wheel_positions =\n { {\n { -handling.front_axle_width * 0.5, -half_wheelbase + handling.wheelbase_offset },\n { handling.front_axle_width * 0.5, -half_wheelbase + handling.wheelbase_offset },\n } };\n }\n\n if (handling.num_rear_wheels >= 2)\n {\n rear_wheel_positions =\n { {\n { -handling.rear_axle_width * 0.5, half_wheelbase + handling.wheelbase_offset },\n { handling.rear_axle_width * 0.5, half_wheelbase + handling.wheelbase_offset }\n } };\n }\n\n auto transform = make_transformation(car.rotation());\n auto inv_transform = make_transformation(-car.rotation());\n\n auto handling_state = car.handling_state();\n handling_state.wheel_states.clear();\n\n auto local_velocity = transform_point(car.velocity(), inv_transform);\n auto local_heading = normalize(local_velocity);\n auto speed = magnitude(local_velocity);\n auto angular_velocity = car.angular_velocity();\n auto mass = car.mass();\n auto center_of_mass = car.center_of_mass();\n\n auto inv_moment = 1.0 / car.moment_of_inertia();\n\n auto num_wheels = handling.num_front_wheels + handling.num_rear_wheels;\n auto inv_num_wheels = 1.0 / num_wheels;\n auto wheel_traction_limit = handling.traction_limit * inv_num_wheels;\n\n auto total_downforce = local_heading.y * local_heading.y * speed * speed * handling.downforce_coefficient;\n if (local_heading.y > 0.0) total_downforce = 0.0;\n\n auto weight_distribution = clamp(center_of_mass.y / (handling.wheelbase_length * 0.5) + 0.5, 0.25, 0.75);\n\n auto rear_downforce = total_downforce * (0.5 + handling.downforce_balance);\n auto front_downforce = total_downforce * (0.5 - handling.downforce_balance);\n\n auto inv_num_front_wheels = 1.0 / handling.num_front_wheels;\n auto inv_num_rear_wheels = 1.0 / handling.num_rear_wheels;\n\n auto front_base_load = wheel_traction_limit * 2.0 * (1.0 - weight_distribution);\n auto rear_base_load = wheel_traction_limit * 2.0 * weight_distribution;\n\n auto front_load_transfer = handling_state.net_force.y * handling.load_transfer * 0.5;\n auto rear_load_transfer = -handling_state.net_force.y * handling.load_transfer * 0.5;\n\n auto front_traction_limit = std::max(front_base_load + (front_load_transfer + front_downforce) * inv_num_front_wheels, 0.0);\n auto rear_traction_limit = std::max(rear_base_load + (rear_load_transfer + rear_downforce) * inv_num_rear_wheels, 0.0);\n\n auto throttle_rate = car.control_state(Control::Throttle) / 255.0;\n auto braking_rate = car.control_state(Control::Brake) / 255.0;\n auto turning_left_rate = car.control_state(Control::Left) / 255.0;\n auto turning_right_rate = car.control_state(Control::Right) / 255.0;\n auto turning_rate = -turning_left_rate + turning_right_rate;\n auto net_throttle = throttle_rate - braking_rate;\n\n auto inv_frame_duration = 1.0 / frame_duration;\n\n auto front_steering = 0.5 - handling.steering_balance;\n auto rear_steering = 0.5 + handling.steering_balance;\n auto steering_multiplier = 1.0 / std::max(front_steering, rear_steering);\n front_steering *= steering_multiplier;\n rear_steering *= steering_multiplier;\n\n auto front_braking = 0.5 - handling.brake_balance;\n auto rear_braking = 0.5 + handling.brake_balance;\n auto braking_multiplier = 1.0 / std::max(front_steering, rear_steering);\n front_braking *= braking_multiplier;\n rear_braking *= braking_multiplier;\n\n auto front_acceleration = 0.0;\n auto rear_acceleration = 0.0;\n if (handling.front_driven && handling.rear_driven)\n {\n front_acceleration = 0.5 * inv_num_front_wheels;\n rear_acceleration = 0.5 * inv_num_rear_wheels;\n }\n\n else if (handling.front_driven)\n {\n front_acceleration = inv_num_front_wheels;\n }\n\n else if (handling.rear_driven)\n {\n rear_acceleration = inv_num_rear_wheels;\n }\n\n auto num_gears = static_cast(handling.gear_ratios.size());\n if (handling_state.current_gear >= 0 && (speed <= 0.0001 || local_heading.y > 0.7) && net_throttle < 0.0)\n {\n handling_state.current_gear = -1;\n }\n\n if (handling_state.current_gear <= 0 && (speed <= 0.0001 || local_heading.y < -0.7) && net_throttle > 0.0)\n {\n auto gear = 0; \n\n while (gear < num_gears && speed * handling.gear_ratios[gear] >= handling.max_engine_revs * 0.8)\n {\n ++gear;\n }\n\n handling_state.current_gear = gear + 1; \n }\n\n if (handling_state.gear_shift_state != 0)\n {\n auto new_gear = handling_state.current_gear;\n if (handling_state.gear_shift_state > 0) ++new_gear;\n else --new_gear;\n\n auto old_ratio = handling.gear_ratios[handling_state.current_gear - 1];\n auto new_ratio = handling.gear_ratios[new_gear - 1];\n\n auto frame_progress = 1.0 / handling.gear_shift_duration;\n auto progress = 1.0 - (std::abs(handling_state.gear_shift_state) * frame_progress);\n\n auto current_ratio = interpolate_linearly(old_ratio, new_ratio, progress);\n auto updated_ratio = interpolate_linearly(old_ratio, new_ratio, progress + frame_progress);\n\n handling_state.engine_rev_speed /= current_ratio;\n handling_state.engine_rev_speed *= updated_ratio;\n\n if (handling_state.gear_shift_state > 0) --handling_state.gear_shift_state;\n else ++handling_state.gear_shift_state;\n\n if (handling_state.gear_shift_state == 0)\n {\n handling_state.current_gear = new_gear;\n }\n }\n\n else if (handling_state.engine_rev_speed >= 0.99)\n {\n if (handling_state.current_gear >= 1 && handling_state.current_gear < num_gears)\n {\n handling_state.gear_shift_state = handling.gear_shift_duration;\n }\n }\n\n else if (handling_state.engine_rev_speed < 0.8 && handling_state.current_gear > 1)\n {\n auto prev_gear = handling_state.current_gear - 1;\n auto new_revs = handling_state.engine_rev_speed;\n new_revs /= handling.gear_ratios[handling_state.current_gear - 1];\n new_revs *= handling.gear_ratios[prev_gear - 1];\n if (new_revs < 0.8)\n {\n handling_state.gear_shift_state = -handling.gear_shift_duration;\n }\n }\n\n auto gear_ratio = 1.0;\n if (handling_state.current_gear < 0)\n {\n net_throttle = -net_throttle;\n gear_ratio = -handling.reverse_gear_ratio;\n }\n\n else if (handling_state.current_gear == 0)\n {\n gear_ratio = 0.0;\n }\n\n else if (handling_state.current_gear - 1 < num_gears)\n {\n gear_ratio = handling.gear_ratios[handling_state.current_gear - 1];\n }\n\n if (handling_state.gear_shift_state == 0)\n {\n handling_state.engine_rev_speed = std::min(speed * std::abs(gear_ratio) / handling.max_engine_revs, 1.05);\n }\n\n else\n {\n gear_ratio = 0.0;\n } \n\n auto throttle_factor = 1.0;\n if (handling_state.engine_rev_speed > 1.0)\n {\n throttle_factor = 0.0;\n }\n\n auto acceleration_force_1d = std::max(net_throttle, 0.0) * handling.max_acceleration_force * gear_ratio * throttle_factor;\n auto braking_force_1d = std::max(-net_throttle, 0.0) * handling.max_braking_force;\n\n struct WheelState\n {\n Vector2d pos;\n Vector2d velocity;\n Vector2d bias;\n Vector2d wheel_facing;\n double heading_angle;\n double traction_limit;\n double vertical_load;\n double acceleration;\n double braking;\n double cornering;\n double max_steering_angle;\n double acceleration_force;\n double braking_force;\n double cornering_force;\n double slide_ratio;\n\n resources::TerrainDefinition terrain;\n };\n\n auto throttle_bias = 1.0;\n auto brake_bias = 1.0;\n auto cornering_bias = 1.0;\n auto antislide_bias = 1.0;\n auto longitudinal_bias = net_throttle >= 0.0 ? throttle_bias : brake_bias;\n\n auto cornering_bias_2d = normalize(make_vector2(cornering_bias, longitudinal_bias));\n auto antislide_bias_2d = normalize(make_vector2(cornering_bias, longitudinal_bias));\n\n boost::container::small_vector wheel_states;\n for (auto p : front_wheel_positions)\n {\n WheelState ws{};\n ws.pos = p;\n ws.traction_limit = front_traction_limit;\n ws.acceleration = front_acceleration;\n ws.braking = front_braking;\n ws.cornering = handling.cornering;\n ws.max_steering_angle = front_steering * degrees(handling.max_steering_angle).radians();\n ws.bias = cornering_bias_2d; \n wheel_states.push_back(ws);\n }\n\n for (auto p : rear_wheel_positions)\n {\n WheelState ws{};\n ws.pos = p;\n ws.traction_limit = rear_traction_limit;\n ws.acceleration = rear_acceleration;\n ws.braking = rear_braking;\n ws.cornering = handling.cornering;\n ws.max_steering_angle = -rear_steering * degrees(handling.max_steering_angle).radians();\n ws.bias = antislide_bias_2d;\n wheel_states.push_back(ws);\n }\n\n auto max_cornering_multiplier = speed * mass * inv_num_wheels * inv_frame_duration;\n auto is_turning = std::abs(turning_rate) >= 0.0001;\n\n auto adjusted_steering_rate = 0.0;\n\n for (auto& ws : wheel_states)\n { \n auto global_pos = car.position() + transform_point(ws.pos, transform);\n\n ws.vertical_load = ws.traction_limit;\n ws.terrain = world.terrain_at(global_pos, car.z_level());\n ws.velocity = local_velocity + angular_velocity * make_vector2(-ws.pos.y, ws.pos.x);\n ws.heading_angle = std::atan2(ws.velocity.x, -ws.velocity.y);\n\n if (is_turning && std::abs(ws.max_steering_angle) >= 0.00001)\n {\n auto max_angle = turning_rate < 0.0 ? -ws.max_steering_angle : ws.max_steering_angle;\n auto desired_angle = degrees(handling.non_slide_angle);\n if (max_angle < 0.0) desired_angle = -desired_angle;\n\n auto steering_angle = radians(ws.heading_angle) + desired_angle;\n if (std::abs(steering_angle.degrees()) >= 90.0)\n {\n steering_angle -= degrees(180.0);\n steering_angle.normalize();\n }\n\n auto steering_rate = std::min(steering_angle.radians() / max_angle, 1.0);\n if (steering_rate > adjusted_steering_rate)\n {\n adjusted_steering_rate = steering_rate;\n }\n }\n }\n\n turning_rate *= adjusted_steering_rate;\n\n auto pedal_adjustment = 1.0; \n for (auto& ws : wheel_states)\n {\n ws.wheel_facing = make_vector2(0.0, -1.0);\n auto steering_angle = radians(turning_rate * ws.max_steering_angle);\n if (std::abs(steering_angle.radians()) >= 0.00001)\n {\n ws.wheel_facing = transform_point(ws.wheel_facing, steering_angle);\n }\n\n auto slip_angle = radians(ws.heading_angle) - steering_angle;\n if (std::abs(slip_angle.degrees()) >= 90.0)\n {\n slip_angle -= degrees(180.0);\n slip_angle.normalize();\n }\n\n auto slip_degrees = std::abs(slip_angle.degrees());\n\n ws.slide_ratio = 1.0;\n auto cornering_ratio = 1.0;\n if (slip_degrees < handling.full_slide_angle)\n {\n if (slip_degrees < handling.non_slide_angle)\n { \n //cornering_ratio = slip_degrees / handling.non_slide_angle;\n ws.slide_ratio = 0.0;\n }\n\n else\n {\n ws.slide_ratio = (slip_degrees - handling.non_slide_angle) /\n (handling.full_slide_angle - handling.non_slide_angle);\n ws.slide_ratio *= ws.slide_ratio;\n }\n }\n\n ws.traction_limit *= interpolate_linearly(ws.terrain.traction, \n handling.sliding_grip * ws.terrain.sliding_traction, \n ws.slide_ratio);\n\n auto facing = ws.wheel_facing;\n if (ws.velocity.y > 0.0) facing = -facing;\n\n auto max_cornering = std::abs(slip_angle.radians()) * max_cornering_multiplier;\n ws.cornering_force = std::min(cornering_ratio * ws.cornering * ws.traction_limit, max_cornering);\n\n auto braking_factor = facing.y * facing.y;\n ws.acceleration_force = ws.acceleration * acceleration_force_1d;\n ws.braking_force = ws.braking * braking_force_1d * braking_factor;\n\n auto longitudinal_force = (std::abs(ws.acceleration_force) + ws.braking_force) * pedal_adjustment;\n auto applied_force = make_vector2(ws.cornering_force, longitudinal_force);\n\n if (magnitude_squared(applied_force) > ws.traction_limit * ws.traction_limit)\n {\n auto reduce_x = applied_force.x > ws.bias.x * ws.traction_limit;\n auto reduce_y = applied_force.y > ws.bias.y * ws.traction_limit;\n\n if (reduce_y)\n {\n if (reduce_x)\n {\n pedal_adjustment = (ws.traction_limit * ws.bias.y) /\n (std::abs(ws.acceleration_force) + ws.braking_force);\n }\n\n else\n {\n auto rem = ws.traction_limit * ws.traction_limit - ws.cornering_force * ws.cornering_force;\n pedal_adjustment = std::sqrt(rem) / (std::abs(ws.acceleration_force) + ws.braking_force);\n }\n }\n }\n }\n\n handling_state.wheel_states.clear();\n auto net_force = make_vector2(0.0, 0.0);\n for (auto& ws : wheel_states)\n {\n {\n auto longitudinal_force = (std::abs(ws.acceleration_force) + ws.braking_force) * pedal_adjustment;\n auto rem = std::max(ws.traction_limit * ws.traction_limit - longitudinal_force * longitudinal_force, 0.0);\n\n if (rem < ws.cornering_force * ws.cornering_force)\n {\n ws.cornering_force = std::sqrt(rem);\n }\n }\n\n auto force = make_vector2(0.0, 0.0);\n\n auto wheel_heading = normalize(ws.velocity);\n auto target_heading = ws.wheel_facing;\n if (ws.velocity.y > 0.0) target_heading = -target_heading;\n auto slide_direction = normalize(target_heading - wheel_heading);\n\n auto terrain_cornering_multiplier = ws.terrain.cornering;\n if (&ws - wheel_states.data() >= handling.num_front_wheels)\n {\n terrain_cornering_multiplier = ws.terrain.antislide;\n } \n\n force += ws.acceleration_force * pedal_adjustment * ws.wheel_facing * ws.terrain.acceleration;\n force += ws.braking_force * pedal_adjustment * -target_heading * ws.terrain.braking;\n force += ws.cornering_force * slide_direction * terrain_cornering_multiplier;\n\n auto rolling_resistance = (1.0 - ws.slide_ratio) * handling.rolling_drag_coefficient * \n ws.vertical_load * ws.terrain.rolling_resistance;\n\n force += rolling_resistance * -wheel_heading;\n\n force += ws.terrain.roughness * mass * -ws.velocity * inv_num_wheels;\n \n car.apply_force(force, ws.pos); \n\n net_force += force;\n\n HandlingState::WheelState stored_info;\n stored_info.pos = car.position() + transform_point(ws.pos, transform);\n stored_info.slide_ratio = ws.slide_ratio;\n stored_info.terrain_color = ws.terrain.color;\n stored_info.terrain_roughness = ws.terrain.roughness;\n stored_info.speed = dot_product(wheel_heading, ws.velocity); \n handling_state.wheel_states.push_back(stored_info);\n }\n\n auto drag = speed * -local_velocity * handling.drag_coefficient;\n car.apply_force(drag, center_of_mass);\n net_force += drag;\n \n auto torque_effect = car.applied_torque() * inv_moment * mass;\n auto min_lateral_force = net_force.x + -wheel_states.front().pos.y * torque_effect;\n auto max_lateral_force = min_lateral_force;\n for (std::uint32_t idx = 1; idx < wheel_states.size(); ++idx)\n {\n auto lateral_force = net_force.x + -wheel_states[idx].pos.y * torque_effect;\n if (lateral_force < min_lateral_force)\n {\n min_lateral_force = lateral_force;\n }\n\n if (lateral_force > max_lateral_force)\n {\n max_lateral_force = lateral_force;\n }\n }\n\n if (std::signbit(min_lateral_force) == std::signbit(max_lateral_force))\n {\n auto m = (max_lateral_force - min_lateral_force) * 0.5;\n auto f = clamp(min_lateral_force < 0.0 ? -max_lateral_force : -min_lateral_force, -m, m);\n car.apply_force(make_vector2(f, 0.0), center_of_mass);\n net_force.x += f;\n }\n\n angular_velocity -= angular_velocity * handling.angular_damping * frame_duration;\n car.set_angular_velocity(angular_velocity);\n handling_state.net_force = net_force; \n return handling_state; \n }\n }\n}\n", "meta": {"hexsha": "dd783a2090469a170b76b4dc60d58d2901ddd723", "size": 18103, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/world/handling_v2.cpp", "max_stars_repo_name": "mnewhouse/tselements", "max_stars_repo_head_hexsha": "bd1c6724018e862156948a680bb1bc70dd28bef6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/world/handling_v2.cpp", "max_issues_repo_name": "mnewhouse/tselements", "max_issues_repo_head_hexsha": "bd1c6724018e862156948a680bb1bc70dd28bef6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/world/handling_v2.cpp", "max_forks_repo_name": "mnewhouse/tselements", "max_forks_repo_head_hexsha": "bd1c6724018e862156948a680bb1bc70dd28bef6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3514056225, "max_line_length": 130, "alphanum_fraction": 0.640225377, "num_tokens": 4390, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7490872131147276, "lm_q2_score": 0.399811640739795, "lm_q1q2_score": 0.2994937877325997}} {"text": "// GMTL is (C) Copyright 2001-2010 by Allen Bierbaum\n// Distributed under the GNU Lesser General Public License 2.1 with an\n// addendum covering inlined code. (See accompanying files LICENSE and\n// LICENSE.addendum or http://www.gnu.org/copyleft/lesser.txt)\n\n// Includes ====================================================================\n#include \n#include \n\n// Using =======================================================================\nusing namespace boost::python;\n\n// Declarations ================================================================\n\n\nnamespace {\n\n\nBOOST_PYTHON_FUNCTION_OVERLOADS(isNormalized_overloads_1_2, gmtl::isNormalized, 1, 2)\n\n\n}// namespace \n\n\n// Module ======================================================================\nvoid _Export_gmtl_VecOps_h()\n{\n def(\"cross\", (gmtl::Vec & (*)(gmtl::Vec &, const gmtl::Vec &, const gmtl::Vec &))&gmtl::cross, return_internal_reference< 1 >());\n def(\"cross\", (gmtl::Vec & (*)(gmtl::Vec &, const gmtl::Vec &, const gmtl::Vec &))&gmtl::cross, return_internal_reference< 1 >());\n def(\"cross\", (gmtl::Vec & (*)(gmtl::Vec &, const gmtl::Vec &, const gmtl::Vec &))&gmtl::cross, return_internal_reference< 1 >());\n def(\"dot\", (double (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (double (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (double (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (float (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (float (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (float (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (int (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (int (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"dot\", (int (*)(const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::dot);\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const double))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const double))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const double))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const float))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const float))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const float))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const int))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const int))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"isNormalized\", (bool (*)(const gmtl::Vec &, const int))&gmtl::isNormalized, isNormalized_overloads_1_2());\n def(\"length\", (double (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (double (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (double (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (float (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (float (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (float (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (int (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (int (*)(const gmtl::Vec &))&gmtl::length);\n def(\"length\", (int (*)(const gmtl::Vec &))&gmtl::length);\n def(\"lengthSquared\", (double (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (double (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (double (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (float (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (float (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (float (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (int (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (int (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lengthSquared\", (int (*)(const gmtl::Vec &))&gmtl::lengthSquared);\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const double &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const double &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const double &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const float &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const float &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const float &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const int &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const int &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"lerp\", (gmtl::VecBase & (*)(gmtl::VecBase &, const int &, const gmtl::VecBase &, const gmtl::VecBase &))&gmtl::lerp, return_internal_reference< 1 >());\n def(\"normalize\", (double (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (double (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (double (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (float (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (float (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (float (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (int (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (int (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"normalize\", (int (*)(gmtl::Vec &))&gmtl::normalize);\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"reflect\", (gmtl::VecBase & (*)(gmtl::VecBase &, const gmtl::VecBase &, const gmtl::Vec &))&gmtl::reflect, return_internal_reference< 1 >());\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const double))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const double))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const double))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const float))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const float))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const float))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const int))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const int))&gmtl::isEqual);\n def(\"isEqual\", (bool (*)(const gmtl::VecBase &, const gmtl::VecBase &, const int))&gmtl::isEqual);\n}\n", "meta": {"hexsha": "e8e0859bec70e51d345befcd57da6a653396314e", "size": 10000, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "gmtl-0.6.1/python/src/gmtl/_gmtl_VecOps_h.cpp", "max_stars_repo_name": "Glitch0011/QuadTree-Example", "max_stars_repo_head_hexsha": "3558c999f68475bc98b8fa33b0f6d14076c9ec48", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gmtl-0.6.1/python/src/gmtl/_gmtl_VecOps_h.cpp", "max_issues_repo_name": "Glitch0011/QuadTree-Example", "max_issues_repo_head_hexsha": "3558c999f68475bc98b8fa33b0f6d14076c9ec48", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gmtl-0.6.1/python/src/gmtl/_gmtl_VecOps_h.cpp", "max_forks_repo_name": "Glitch0011/QuadTree-Example", "max_forks_repo_head_hexsha": "3558c999f68475bc98b8fa33b0f6d14076c9ec48", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 96.1538461538, "max_line_length": 203, "alphanum_fraction": 0.6243, "num_tokens": 3336, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.29940597603736574}} {"text": "#include \"interpolate.h\"\n#include \"geoutil.h\"\n#include \"lambert_conformal_grid.h\"\n#include \"latitude_longitude_grid.h\"\n#include \"numerical_functions.h\"\n#include \"point_list.h\"\n#include \"reduced_gaussian_grid.h\"\n#include \"stereographic_grid.h\"\n#include \"util.h\"\n\n#include \"plugin_factory.h\"\n#include \n\n#define HIMAN_AUXILIARY_INCLUDE\n\n#include \"querydata.h\"\n\n#undef HIMAN_AUXILIARY_INCLUDE\n\nusing namespace himan;\nusing namespace Eigen;\n\nnamespace himan\n{\nnamespace interpolate\n{\n// Function to return identifier for each supported datatype\n// In the interpolation weight cache we store weights separately\n// for each data type.\n\ntemplate \nint DataTypeId();\n\ntemplate <>\nint DataTypeId()\n{\n\treturn 1;\n}\n\ntemplate <>\nint DataTypeId()\n{\n\treturn 2;\n}\n\ntemplate <>\nint DataTypeId()\n{\n\treturn 3;\n}\ntemplate <>\nint DataTypeId()\n{\n\treturn 4;\n}\n\nbool IsSupportedGridForRotation(HPGridType type)\n{\n\tswitch (type)\n\t{\n\t\tcase kRotatedLatitudeLongitude:\n\t\tcase kStereographic:\n\t\tcase kLambertConformalConic:\n\t\t\treturn true;\n\t\tdefault:\n\t\t\treturn false;\n\t}\n}\n\ntemplate \nbool InterpolateArea(const grid* baseGrid, std::shared_ptr> source)\n{\n\tif (!source)\n\t{\n\t\treturn false;\n\t}\n\n#ifdef HAVE_CUDA\n\tif (source->PackedData()->HasData())\n\t{\n\t\tutil::Unpack({source});\n\t}\n#endif\n\n\tbase target;\n\ttarget.grid = std::shared_ptr(baseGrid->Clone());\n\n\tif (baseGrid->Class() == kRegularGrid)\n\t{\n\t\ttarget.data.Resize(dynamic_cast(baseGrid)->Ni(),\n\t\t dynamic_cast(baseGrid)->Nj());\n\t}\n\telse if (baseGrid->Class() == kIrregularGrid)\n\t{\n\t\ttarget.data.Resize(baseGrid->Size(), 1);\n\t}\n\n\tauto method = InterpolationMethod(source->Param().Name(), source->Param().InterpolationMethod());\n\n\tlogger logr(\"interpolation\");\n\tlogr.Trace(fmt::format(\"Grid interpolation with method '{}'\", HPInterpolationMethodToString.at(method)));\n\n\tif (interpolate::interpolator().Interpolate(*source->Base(), target, method))\n\t{\n\t\tauto interpGrid = std::shared_ptr(baseGrid->Clone());\n\n\t\tinterpGrid->UVRelativeToGrid(source->Grid()->UVRelativeToGrid());\n\n\t\tsource->Base()->grid = interpGrid;\n\t\tsource->Base()->data = std::move(target.data);\n\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\ntemplate bool InterpolateArea(const grid*, std::shared_ptr>);\ntemplate bool InterpolateArea(const grid*, std::shared_ptr>);\ntemplate bool InterpolateArea(const grid*, std::shared_ptr>);\ntemplate bool InterpolateArea(const grid*, std::shared_ptr>);\n\ntemplate \nbool ReorderPoints(const grid* baseGrid, std::shared_ptr> info)\n{\n\tif (!info)\n\t{\n\t\treturn false;\n\t}\n\n\t// Worst case: cartesian product ie O(n^2)\n\n\tauto targetStations = dynamic_cast(baseGrid)->Stations();\n\tauto sourceStations = std::dynamic_pointer_cast(info->Grid())->Stations();\n\tconst auto& sourceData = info->Data();\n\tmatrix newData(targetStations.size(), 1, 1, MissingValue());\n\n\tif (targetStations.size() == 0 || sourceStations.size() == 0)\n\t{\n\t\treturn false;\n\t}\n\n\tstd::vector newStations;\n\n\tfor (size_t i = 0; i < targetStations.size(); i++)\n\t{\n\t\tstation s1 = targetStations[i];\n\n\t\tbool found = false;\n\n\t\tfor (size_t j = 0; j < sourceStations.size() && !found; j++)\n\t\t{\n\t\t\tstation s2 = sourceStations[j];\n\n\t\t\tif (s1.Id() == s2.Id())\n\t\t\t{\n\t\t\t\tnewStations.push_back(s1);\n\t\t\t\tnewData.Set(i, sourceData.At(j));\n\n\t\t\t\tfound = true;\n\t\t\t}\n\t\t}\n\n\t\tif (!found)\n\t\t{\n\t\t\t// throw std::runtime_error(\"Failed, source data does not contain all the same points as target\");\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tstd::dynamic_pointer_cast(info->Grid())->Stations(newStations);\n\n\tauto b = info->Base();\n\tb->data = std::move(newData);\n\n\treturn true;\n}\n\ntemplate bool ReorderPoints(const grid*, std::shared_ptr>);\ntemplate bool ReorderPoints(const grid*, std::shared_ptr>);\ntemplate bool ReorderPoints(const grid*, std::shared_ptr>);\ntemplate bool ReorderPoints(const grid*, std::shared_ptr>);\n\ntemplate \nbool Interpolate(const grid* baseGrid, const std::vector>>& infos)\n{\n\tfor (const auto& info : infos)\n\t{\n\t\tbool needInterpolation = false;\n\t\tbool needPointReordering = false;\n\n\t\t/*\n\t\t * Possible scenarios:\n\t\t * 1. from regular to regular (basic area&grid interpolation)\n\t\t * 2. from regular to irregular (area to point)\n\t\t * 3. from irregular to irregular (limited functionality, basically just point reordering)\n\t\t * 4. from irregular to regular, not supported, except if source is gaussian\n\t\t */\n\n\t\t// 1.\n\n\t\tif (baseGrid->Class() == kRegularGrid && info->Grid()->Class() == kRegularGrid)\n\t\t{\n\t\t\tif (*baseGrid != *info->Grid())\n\t\t\t{\n\t\t\t\tneedInterpolation = true;\n\t\t\t}\n\n\t\t\t// == operator does not test scanning mode !\n\n\t\t\telse if (dynamic_cast(baseGrid)->ScanningMode() !=\n\t\t\t std::dynamic_pointer_cast(info->Grid())->ScanningMode())\n\t\t\t{\n#ifdef HAVE_CUDA\n\t\t\t\tif (info->PackedData()->HasData())\n\t\t\t\t{\n\t\t\t\t\t// must unpack before swapping\n\t\t\t\t\tutil::Unpack({info});\n\t\t\t\t}\n#endif\n\t\t\t\tutil::Flip(info->Data());\n\t\t\t\tauto base = info->Base();\n\t\t\t\tconst bool uv = base->grid->UVRelativeToGrid();\n\t\t\t\tbase->grid = std::shared_ptr(baseGrid->Clone());\n\t\t\t\tbase->grid->UVRelativeToGrid(uv);\n\t\t\t}\n\t\t}\n\n\t\t// 2.\n\n\t\telse if (baseGrid->Class() == kIrregularGrid && info->Grid()->Class() == kRegularGrid)\n\t\t{\n\t\t\tneedInterpolation = true;\n\t\t}\n\n\t\t// 3.\n\n\t\telse if (baseGrid->Class() == kIrregularGrid && info->Grid()->Class() == kIrregularGrid)\n\t\t{\n\t\t\tif (*baseGrid != *info->Grid())\n\t\t\t{\n\t\t\t\tneedPointReordering = true;\n\t\t\t}\n\t\t}\n\n\t\t// 4.\n\n\t\telse if (baseGrid->Class() == kRegularGrid && info->Grid()->Class() == kIrregularGrid)\n\t\t{\n\t\t\tif (info->Grid()->Type() == kReducedGaussian)\n\t\t\t{\n\t\t\t\tneedInterpolation = true;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tthrow std::runtime_error(\"Unable to extrapolate from points to grid\");\n\t\t\t}\n\t\t}\n\n\t\tif (needInterpolation && InterpolateArea(baseGrid, info) == false)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t\telse if (needPointReordering && ReorderPoints(baseGrid, info) == false)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t\telse if (needInterpolation == false && needPointReordering == false)\n\t\t{\n\t\t\tlogger logr(\"interpolate\");\n\t\t\tlogr.Trace(\"Areas are equal, no need to interpolate\");\n\t\t}\n\t}\n\n\treturn true;\n}\n\ntemplate bool Interpolate(const grid*, const std::vector>>&);\ntemplate bool Interpolate(const grid*, const std::vector>>&);\ntemplate bool Interpolate(const grid*, const std::vector>>&);\ntemplate bool Interpolate(const grid*, const std::vector>>&);\n\nbool IsVectorComponent(const std::string& paramName)\n{\n\tif (paramName == \"U-MS\" || paramName == \"V-MS\" || paramName == \"WGU-MS\" || paramName == \"WGV-MS\" ||\n\t paramName == \"IVELU-MS\" || paramName == \"IVELV-MS\" || paramName == \"WVELU-MS\" || paramName == \"WVELV-MS\")\n\t{\n\t\treturn true;\n\t}\n\n\treturn false;\n}\n\nbool IsNumericCodeTable(const std::string& paramName)\n{\n\tif (paramName.find(\"NWCSAF_CLDTYPE\") != std::string::npos ||\n\t paramName.find(\"NWCSAF_CLDMASK\") != std::string::npos || paramName == \"NWCSAF_CTTH_QC-N\" ||\n\t paramName == \"CLDTYPE-N\")\n\t{\n\t\treturn true;\n\t}\n\treturn false;\n}\n\nHPInterpolationMethod InterpolationMethod(const std::string& paramName, HPInterpolationMethod interpolationMethod)\n{\n\t// Later we'll add this information to radon directly\n\tif (interpolationMethod == kBiLinear &&\n\t (\n\t // vector parameters\n\t IsVectorComponent(paramName) || paramName == \"DD-D\" || paramName == \"FF-MS\" ||\n\t // precipitation\n\t paramName == \"RR-KGM2\" || paramName == \"SNR-KGM2\" || paramName == \"GRI-KGM2\" || paramName == \"RRR-KGM2\" ||\n\t paramName == \"RRRC-KGM2\" || paramName == \"RRRL-KGM2\" || paramName == \"SNRC-KGM2\" ||\n\t paramName == \"SNRL-KGM2\" || paramName == \"RRRS-KGM2\" || paramName == \"RR-1-MM\" || paramName == \"RR-3-MM\" ||\n\t paramName == \"RR-6-MM\" || paramName == \"RRI-KGM2\" || paramName == \"SNRI-KGM2\" ||\n\t paramName == \"SNACC-KGM2\" ||\n\t // symbols\n\t paramName == \"CLDSYM-N\" || paramName == \"PRECFORM-N\" || paramName == \"PRECFORM2-N\" ||\n\t paramName == \"FOGSYM-N\" || paramName == \"ICING-N\" || paramName == \"POTPRECT-N\" ||\n\t paramName == \"POTPRECF-N\" || paramName == \"FOGINT-N\" || paramName == \"PRECTYPE-N\" ||\n\t // code tables\n\t IsNumericCodeTable(paramName)))\n\t{\n#ifdef DEBUG\n\t\tstd::cout << \"Debug::interpolation Switching interpolation method from bilinear to nearest point\" << std::endl;\n#endif\n\t\treturn kNearestPoint; // nearest point in himan and newbase\n\t}\n\n\treturn interpolationMethod;\n}\n\ntemplate \nvoid RotateVectorComponentsCPU(const grid* from, const grid* to, himan::matrix& U, himan::matrix& V)\n{\n\t// First convert to earth relative\n\n\tlogger log(\"interpolate\");\n\n\tif (from->UVRelativeToGrid() && from->Type() != kLatitudeLongitude)\n\t{\n\t\tlog.Trace(\"Rotating from \" + HPGridTypeToString.at(from->Type()) + \" to earth relative\");\n\n\t\tswitch (from->Type()) // source type\n\t\t{\n\t\t\tcase kLatitudeLongitude:\n\t\t\t\tbreak;\n\t\t\tcase kRotatedLatitudeLongitude:\n\t\t\t{\n\t\t\t\tconst auto rll = dynamic_cast(from);\n\t\t\t\tpoint southPole = rll->SouthPole();\n\n\t\t\t\tif (southPole.Y() > 0)\n\t\t\t\t{\n\t\t\t\t\tsouthPole.Y(-southPole.Y());\n\t\t\t\t\tsouthPole.X(0);\n\t\t\t\t}\n\n\t\t\t\tfor (size_t i = 0; i < U.Size(); i++)\n\t\t\t\t{\n\t\t\t\t\tT u = U[i];\n\t\t\t\t\tT v = V[i];\n\n\t\t\t\t\tconst point rotPoint = rll->RotatedLatLon(i);\n\t\t\t\t\tconst point regPoint = rll->LatLon(i);\n\n\t\t\t\t\t// Algorithm by J.E. HAUGEN (HIRLAM JUNE -92), modified by K. EEROLA\n\t\t\t\t\t// Algorithm originally defined in hilake/TURNDD.F\n\n\t\t\t\t\tconst double southPoleY = constants::kDeg * (southPole.Y() + 90);\n\n\t\t\t\t\tdouble sinPoleY, cosPoleY;\n\t\t\t\t\tsincos(southPoleY, &sinPoleY, &cosPoleY);\n\n\t\t\t\t\tconst double cosRegY = cos(constants::kDeg * regPoint.Y()); // zcyreg\n\t\t\t\t\tconst double zxmxc = constants::kDeg * (regPoint.X() - southPole.X());\n\n\t\t\t\t\tdouble sinxmxc, cosxmxc;\n\t\t\t\t\tsincos(zxmxc, &sinxmxc, &cosxmxc);\n\n\t\t\t\t\tconst double rotXRad = constants::kDeg * rotPoint.X();\n\t\t\t\t\tconst double rotYRad = constants::kDeg * rotPoint.Y();\n\n\t\t\t\t\tdouble sinRotX, cosRotX;\n\t\t\t\t\tsincos(rotXRad, &sinRotX, &cosRotX);\n\n\t\t\t\t\tdouble sinRotY, cosRotY;\n\t\t\t\t\tsincos(rotYRad, &sinRotY, &cosRotY);\n\n\t\t\t\t\tconst double PA = cosxmxc * cosRotX + cosPoleY * sinxmxc * sinRotX;\n\t\t\t\t\tconst double PB = cosPoleY * sinxmxc * cosRotX * sinRotY + sinPoleY * sinxmxc * cosRotY -\n\t\t\t\t\t cosxmxc * sinRotX * sinRotY;\n\t\t\t\t\tconst double PC = (-sinPoleY) * sinRotX / cosRegY;\n\t\t\t\t\tconst double PD = (cosPoleY * cosRotY - sinPoleY * cosRotX * sinRotY) / cosRegY;\n\n\t\t\t\t\tU[i] = static_cast(PA * u + PB * v);\n\t\t\t\t\tV[i] = static_cast(PC * u + PD * v);\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\n\t\t\tcase kLambertConformalConic:\n\t\t\t{\n\t\t\t\tauto lcc = dynamic_cast(from);\n\t\t\t\tconst double cone = lcc->Cone();\n\t\t\t\tconst double orientation = lcc->Orientation();\n\n\t\t\t\tfor (size_t i = 0; i < U.Size(); i++)\n\t\t\t\t{\n\t\t\t\t\tT u = U[i];\n\t\t\t\t\tT v = V[i];\n\n\t\t\t\t\t// http://www.mcs.anl.gov/~emconsta/wind_conversion.txt\n\n\t\t\t\t\tdouble angle = from->LatLon(i).X() - orientation;\n\t\t\t\t\tASSERT(angle >= -180 && angle <= 180);\n\n\t\t\t\t\tconst double anglex = cone * angle * constants::kDeg;\n\t\t\t\t\tdouble sinx, cosx;\n\t\t\t\t\tsincos(anglex, &sinx, &cosx);\n\n\t\t\t\t\tU[i] = static_cast(cosx * u + sinx * v);\n\t\t\t\t\tV[i] = static_cast(-1 * sinx * u + cosx * v);\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\n\t\t\tcase kStereographic:\n\t\t\t{\n\t\t\t\t// The same as lambert but with cone = 1\n\n\t\t\t\tconst double orientation = dynamic_cast(from)->Orientation();\n\n\t\t\t\tfor (size_t i = 0; i < U.Size(); i++)\n\t\t\t\t{\n\t\t\t\t\tT u = U[i];\n\t\t\t\t\tT v = V[i];\n\n\t\t\t\t\tconst double angle = (from->LatLon(i).X() - orientation) * constants::kDeg;\n\t\t\t\t\tdouble sinx, cosx;\n\n\t\t\t\t\tsincos(angle, &sinx, &cosx);\n\n\t\t\t\t\tU[i] = static_cast(cosx * u + sinx * v);\n\t\t\t\t\tV[i] = static_cast(-1 * sinx * u + cosx * v);\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow std::runtime_error(\"Unable to rotate from \" + HPGridTypeToString.at(from->Type()) + \" to \" +\n\t\t\t\t HPGridTypeToString.at(to->Type()));\n\t\t}\n\t}\n\n\tif (to->UVRelativeToGrid() == false)\n\t{\n\t\tlog.Trace(\"Result grid has UVRelativeToGrid=false, no need for further rotation\");\n\t\treturn;\n\t}\n\n\tswitch (to->Type())\n\t{\n\t\tcase kLatitudeLongitude:\n\t\t\tbreak;\n\n\t\tcase kRotatedLatitudeLongitude:\n\t\t{\n\t\t\tconst auto rll = dynamic_cast(to);\n\t\t\tpoint southPole = rll->SouthPole();\n\n\t\t\tif (southPole.Y() > 0)\n\t\t\t{\n\t\t\t\tsouthPole.Y(-southPole.Y());\n\t\t\t\tsouthPole.X(0);\n\t\t\t}\n\n\t\t\tfor (size_t i = 0; i < U.Size(); i++)\n\t\t\t{\n\t\t\t\tT u = U[i];\n\t\t\t\tT v = V[i];\n\n\t\t\t\tconst point rotPoint = rll->RotatedLatLon(i);\n\t\t\t\tconst point regPoint = rll->LatLon(i);\n\n\t\t\t\t// Algorithm by J.E. HAUGEN (HIRLAM JUNE -92), modified by K. EEROLA\n\t\t\t\t// Algorithm originally defined in hilake/TURNDD.F\n\n\t\t\t\tconst double southPoleY = constants::kDeg * (southPole.Y() + 90);\n\n\t\t\t\tdouble sinPoleY, cosPoleY;\n\t\t\t\tsincos(southPoleY, &sinPoleY, &cosPoleY);\n\n\t\t\t\tconst double sinRegY = sin(constants::kDeg * regPoint.Y()); // zsyreg\n\t\t\t\tconst double cosRegY = cos(constants::kDeg * regPoint.Y()); // zcyreg\n\n\t\t\t\tdouble zxmxc = constants::kDeg * (regPoint.X() - southPole.X());\n\n\t\t\t\tdouble sinxmxc, cosxmxc;\n\t\t\t\tsincos(zxmxc, &sinxmxc, &cosxmxc);\n\n\t\t\t\tconst double rotXRad = constants::kDeg * rotPoint.X();\n\n\t\t\t\tdouble sinRotX, cosRotX;\n\t\t\t\tsincos(rotXRad, &sinRotX, &cosRotX);\n\n\t\t\t\tconst double cosRotY = cos(constants::kDeg * rotPoint.Y()); // zcyrot\n\n\t\t\t\tconst double PA = cosPoleY * sinxmxc * sinRotX + cosxmxc * cosRotX;\n\t\t\t\tconst double PB =\n\t\t\t\t cosPoleY * cosxmxc * sinRegY * sinRotX - sinPoleY * cosRegY * sinRotX - sinxmxc * sinRegY * cosRotX;\n\t\t\t\tconst double PC = sinPoleY * sinxmxc / cosRotY;\n\t\t\t\tconst double PD = (sinPoleY * cosxmxc * sinRegY + cosPoleY * cosRegY) / cosRotY;\n\n\t\t\t\tU[i] = static_cast(PA * u + PB * v);\n\t\t\t\tV[i] = static_cast(PC * u + PD * v);\n\t\t\t}\n\t\t}\n\t\tbreak;\n\n\t\tcase kLambertConformalConic:\n\t\t{\n\t\t\tauto lcc = dynamic_cast(to);\n\t\t\tconst double cone = lcc->Cone();\n\t\t\tconst double orientation = lcc->Orientation();\n\n\t\t\tfor (size_t i = 0; i < U.Size(); i++)\n\t\t\t{\n\t\t\t\tT u = U[i];\n\t\t\t\tT v = V[i];\n\n\t\t\t\t// http://www.mcs.anl.gov/~emconsta/wind_conversion.txt\n\n\t\t\t\tconst double angle = to->LatLon(i).X() - orientation;\n\t\t\t\tASSERT(angle >= -180 && angle <= 180);\n\n\t\t\t\tconst double anglex = cone * angle * constants::kDeg;\n\t\t\t\tdouble sinx, cosx;\n\t\t\t\tsincos(anglex, &sinx, &cosx);\n\n\t\t\t\tU[i] = static_cast(cosx * u - sinx * v);\n\t\t\t\tV[i] = static_cast(sinx * u + cosx * v);\n\t\t\t}\n\t\t}\n\t\tbreak;\n\t\tcase kStereographic:\n\t\t{\n\t\t\tconst double orientation = dynamic_cast(to)->Orientation();\n\n\t\t\tfor (size_t i = 0; i < U.Size(); i++)\n\t\t\t{\n\t\t\t\tT u = U[i];\n\t\t\t\tT v = V[i];\n\n\t\t\t\tconst double angle = (to->LatLon(i).X() - orientation) * constants::kDeg;\n\t\t\t\tdouble sinx, cosx;\n\n\t\t\t\tsincos(angle, &sinx, &cosx);\n\n\t\t\t\tU[i] = static_cast(cosx * u - sinx * v);\n\t\t\t\tV[i] = static_cast(sinx * u + cosx * v);\n\t\t\t}\n\t\t}\n\t\tbreak;\n\n\t\tdefault:\n\t\t\tthrow std::runtime_error(\"Unable to rotate from \" + HPGridTypeToString.at(from->Type()) + \" to \" +\n\t\t\t HPGridTypeToString.at(to->Type()));\n\t}\n}\n\ntemplate void RotateVectorComponentsCPU(const grid*, const grid*, himan::matrix&,\n himan::matrix&);\ntemplate void RotateVectorComponentsCPU(const grid*, const grid*, himan::matrix&, himan::matrix&);\ntemplate void RotateVectorComponentsCPU(const grid*, const grid*, himan::matrix&, himan::matrix&);\ntemplate void RotateVectorComponentsCPU(const grid*, const grid*, himan::matrix&,\n himan::matrix&);\n\ntemplate \nvoid RotateVectorComponents(const grid* from, const grid* to, himan::info& UInfo, himan::info& VInfo,\n bool useCuda)\n{\n\tASSERT(UInfo.Grid()->UVRelativeToGrid() == VInfo.Grid()->UVRelativeToGrid());\n\n\tlogger log(\"interpolate\");\n\tif (!UInfo.Grid()->UVRelativeToGrid())\n\t{\n\t\tlog.Trace(\"Source data is not relative to grid -- skipping rotation\");\n\t\treturn;\n\t}\n\n#ifdef HAVE_CUDA\n\tif (useCuda)\n\t{\n\t\tif (UInfo.PackedData()->HasData() || VInfo.PackedData()->HasData())\n\t\t{\n\t\t\tthrow std::runtime_error(\"Packed data needs to be unpacked before rotation on GPU\");\n\t\t}\n\n\t\tcudaStream_t stream;\n\t\tCUDA_CHECK(cudaStreamCreate(&stream));\n\t\tRotateVectorComponentsGPU(from, to, UInfo.Data(), VInfo.Data(), stream, 0, 0, 0);\n\t\tCUDA_CHECK(cudaStreamSynchronize(stream));\n\t}\n\telse\n#endif\n\t{\n\t\tRotateVectorComponentsCPU(from, to, UInfo.Data(), VInfo.Data());\n\t}\n\n\tUInfo.Grid()->UVRelativeToGrid(false);\n\tVInfo.Grid()->UVRelativeToGrid(false);\n}\n\ntemplate void RotateVectorComponents(const grid*, const grid*, info&, info&, bool);\ntemplate void RotateVectorComponents(const grid*, const grid*, info&, info&, bool);\ntemplate void RotateVectorComponents(const grid*, const grid*, info&, info&, bool);\ntemplate void RotateVectorComponents(const grid*, const grid*, info&,\n info&, bool);\n\ntemplate \nstd::pair, std::vector> InterpolationWeights(reduced_gaussian_grid& source, point target)\n{\n\t// target lon 0 <= lon < 360\n\tif (target.X() < 0.0)\n\t\ttarget.X(target.X() + 360.0);\n\telse if (target.X() >= 360.0)\n\t\ttarget.X(target.X() - 360.0);\n\n\tconst auto lats = source.Latitudes();\n\n\t// check if point is inside domain\n\tif (target.Y() >= lats.front())\n\t{\n\t\t// point north of domain\n\t\treturn std::make_pair(std::vector{0}, std::vector{MissingValue()});\n\t}\n\n\tif (target.Y() <= lats.back())\n\t{\n\t\t// point south of domain\n\t\treturn std::make_pair(std::vector{0}, std::vector{MissingValue()});\n\t}\n\n\t// find y-indices\n\tauto south = std::lower_bound(lats.begin(), lats.end(), target.Y(), std::greater_equal());\n\tauto north = south;\n\tnorth--;\n\n\tsize_t y_north = static_cast(std::distance(lats.begin(), north));\n\tsize_t y_south = static_cast(std::distance(lats.begin(), south));\n\n\t// find x-indices\n\tsize_t x_north_west = static_cast(\n\t std::floor(static_cast(source.NumberOfPointsAlongParallels()[y_north]) * target.X() / 360.));\n\tsize_t x_north_east =\n\t x_north_west < static_cast(source.NumberOfPointsAlongParallels()[y_north] - 1) ? x_north_west + 1 : 0;\n\tsize_t x_south_west = static_cast(\n\t std::floor(static_cast(source.NumberOfPointsAlongParallels()[y_south]) * target.X() / 360.));\n\tsize_t x_south_east =\n\t x_south_west < static_cast(source.NumberOfPointsAlongParallels()[y_south] - 1) ? x_south_west + 1 : 0;\n\n\t/*\n\t *\n\t * a---------------b\n\t * | |\n\t * \\ p |\n\t * | |\n\t * c--------------d\n\t *\n\t * Now we know the indices x|y of the four points a,b,c,d that surround p\n\t */\n\n\tstd::vector idxs;\n\tidxs.reserve(4);\n\tidxs.push_back(source.LocationIndex(x_north_west, y_north));\n\tidxs.push_back(source.LocationIndex(x_north_east, y_north));\n\tidxs.push_back(source.LocationIndex(x_south_west, y_south));\n\tidxs.push_back(source.LocationIndex(x_south_east, y_south));\n\n\t// calculate weights by bilinear interpolation to point target (p) surrounded by points A|B|C|D\n\tconst point& p = target;\n\tconst point a = source.LatLon(idxs[0]);\n\tconst point b = source.LatLon(idxs[1]);\n\tconst point c = source.LatLon(idxs[2]);\n\tconst point d = source.LatLon(idxs[3]);\n\n\tstd::vector weights(4);\n\n\t// Matrices and Vectors\n\tEigen::Matrix4d A(4, 4);\n\tEigen::MatrixXd xi(4, 2);\n\tEigen::Vector4d x(4);\n\tEigen::Vector2d phi(2);\n\n\t// Construct linear system of equations to be solved\n\tA(0, 0) = 1;\n\tA(1, 0) = 1;\n\tA(2, 0) = 1;\n\tA(3, 0) = 1;\n\tA(0, 1) = a.X();\n\tA(1, 1) = b.X() == 0.0 ? 360 : b.X();\n\n\tA(2, 1) = c.X();\n\tA(3, 1) = d.X() == 0.0 ? 360 : d.X();\n\n\tA(0, 2) = a.Y();\n\tA(1, 2) = b.Y();\n\tA(2, 2) = c.Y();\n\tA(3, 2) = d.Y();\n\tA(0, 3) = a.X() * a.Y();\n\tA(1, 3) = b.X() == 0.0 ? 360 * b.Y() : b.X() * b.Y();\n\tA(2, 3) = c.X() * c.Y();\n\tA(3, 3) = d.X() == 0.0 ? 360 * d.Y() : d.X() * d.Y();\n\n\txi(0, 0) = 0;\n\txi(1, 0) = 1;\n\txi(2, 0) = 0;\n\txi(3, 0) = 1;\n\txi(0, 1) = 1;\n\txi(1, 1) = 1;\n\txi(2, 1) = 0;\n\txi(3, 1) = 0;\n\n\t// Solve linear system\n\txi = A.colPivHouseholderQr().solve(xi);\n\n\tx[0] = 1;\n\tx[1] = p.X();\n\tx[2] = p.Y();\n\tx[3] = p.X() * p.Y();\n\n\txi.transposeInPlace();\n\tphi = xi * x;\n\n\tweights[0] = static_cast((1 - phi[0]) * phi[1]);\n\tweights[1] = static_cast(phi[0] * phi[1]);\n\tweights[2] = static_cast((1 - phi[0]) * (1 - phi[1]));\n\tweights[3] = static_cast(phi[0] * (1 - phi[1]));\n\n\treturn std::make_pair(idxs, weights);\n}\n\ntemplate \nstd::pair, std::vector> InterpolationWeights(const regular_grid& source, const point& xy)\n{\n\tif (IsMissing(xy.X()) || IsMissing(xy.Y()))\n\t\treturn std::make_pair(std::vector{0}, std::vector{MissingValue()});\n\n\tstd::vector idxs{static_cast(xy.X()) + source.Ni() * static_cast(xy.Y()),\n\t static_cast(xy.X()) + source.Ni() * static_cast(xy.Y()) + 1 -\n\t (static_cast(xy.X()) == source.Ni() - 1 ? source.Ni() : 0),\n\t static_cast(xy.X()) + source.Ni() * static_cast(xy.Y() + 1),\n\t static_cast(xy.X()) + source.Ni() * static_cast(xy.Y() + 1) + 1 -\n\t (static_cast(xy.X()) == source.Ni() - 1 ? source.Ni() : 0)};\n\n\tstd::vector weights(4);\n\n\tweights[0] = static_cast((1 - std::fmod(xy.X(), 1)) * (1 - std::fmod(xy.Y(), 1)));\n\tweights[1] = static_cast(std::fmod(xy.X(), 1) * (1 - std::fmod(xy.Y(), 1)));\n\tweights[2] = static_cast((1 - std::fmod(xy.X(), 1)) * std::fmod(xy.Y(), 1));\n\tweights[3] = static_cast(std::fmod(xy.X(), 1) * std::fmod(xy.Y(), 1));\n\n\t// Index is outside grid. This happens when target point is located on bottom edge\n\t// Set index to first grid point\n\tfor (auto& idx : idxs)\n\t{\n\t\tif (idx > source.Size() - 1)\n\t\t{\n\t\t\tidx = 0;\n\t\t}\n\t}\n\n\treturn std::make_pair(idxs, weights);\n}\n\ntemplate \nstd::vector, std::vector>> InterpolationWeights(const regular_grid& source,\n const std::vector& targets)\n{\n\tstd::vector, std::vector>> ret;\n\tret.reserve(targets.size());\n\n\tfor (const auto& xy : targets)\n\t{\n\t\tret.push_back(InterpolationWeights(source, xy));\n\t}\n\n\treturn ret;\n}\n\ntemplate \nstd::pair NearestPoint(reduced_gaussian_grid& source, point target)\n{\n\t// target lon 0 <= lon < 360\n\tif (target.X() < 0.0)\n\t\ttarget.X(target.X() + 360.0);\n\telse if (target.X() >= 360.0)\n\t\ttarget.X(target.X() - 360.0);\n\n\tconst auto lats = source.Latitudes();\n\n\t// find y-indices\n\tauto south = std::lower_bound(lats.begin(), lats.end(), target.Y(), std::greater_equal());\n\tauto north = south;\n\tnorth--;\n\n\tsize_t y_north = std::distance(lats.begin(), north);\n\tsize_t y_south = std::distance(lats.begin(), south);\n\n\t// find x-indices\n\tsize_t x_north_west = static_cast(\n\t std::floor(static_cast(source.NumberOfPointsAlongParallels()[y_north]) * target.X() / 360.));\n\tsize_t x_north_east =\n\t x_north_west < static_cast(source.NumberOfPointsAlongParallels()[y_north] - 1) ? x_north_west + 1 : 0;\n\tsize_t x_south_west = static_cast(\n\t std::floor(static_cast(source.NumberOfPointsAlongParallels()[y_south]) * target.X() / 360.));\n\tsize_t x_south_east =\n\t x_south_west < static_cast(source.NumberOfPointsAlongParallels()[y_south] - 1) ? x_south_west + 1 : 0;\n\n\tsize_t nearest = x_north_west;\n\tfor (auto p : {x_north_east, x_south_west, x_south_east})\n\t{\n\t\tif (geoutil::Distance(source.LatLon(p), target) < geoutil::Distance(source.LatLon(nearest), target))\n\t\t\tnearest = p;\n\t}\n\n\treturn std::make_pair(nearest, 1.0);\n}\n\ntemplate \nstd::pair NearestPoint(const regular_grid& source, const point& xy)\n{\n\tif (IsMissing(xy.X()) || IsMissing(xy.Y()))\n\t{\n\t\treturn std::make_pair(0, MissingValue());\n\t}\n\t// In case of point in wrap-around region on global grid\n\tif (static_cast(std::round(xy.X())) == source.Ni())\n\t{\n\t\treturn std::make_pair(source.Ni() * static_cast(std::round(xy.Y())), 1.0);\n\t}\n\treturn std::make_pair(\n\t static_cast(std::round(xy.X())) + source.Ni() * static_cast(std::round(xy.Y())), 1.0);\n}\n\ntemplate \nstd::vector> NearestPoint(const regular_grid& source, const std::vector& targets)\n{\n\tstd::vector> ret;\n\tret.reserve(targets.size());\n\n\tfor (const auto& xy : targets)\n\t{\n\t\tret.push_back(NearestPoint(source, xy));\n\t}\n\n\treturn ret;\n}\n\n// area_interpolation class member functions definitions\ntemplate \narea_interpolation::area_interpolation(grid& source, grid& target, HPInterpolationMethod method)\n : itsInterpolation(target.Size(), source.Size())\n{\n\tstd::vector> coefficients;\n\n\tstd::string useOldMethod = \"no\";\n\ttry\n\t{\n\t\tuseOldMethod = util::GetEnv(\"HIMAN_USE_OLD_PROJECTION_METHOD\");\n\t}\n\tcatch (...)\n\t{\n\t}\n\n\t// default to using new 'bulk' method\n\tif (source.Class() == target.Class() && source.Class() == kRegularGrid && useOldMethod == \"no\")\n\t{\n\t\tconst regular_grid& sg = dynamic_cast(source);\n\t\tconst regular_grid& tg = dynamic_cast(target);\n\n\t\tstd::vector xy = sg.XY(tg);\n\t\tstd::vector, std::vector>> ws;\n\n\t\tif (method == kBiLinear)\n\t\t{\n\t\t\tws = InterpolationWeights(sg, xy);\n\t\t}\n\t\telse if (method == kNearestPoint)\n\t\t{\n\t\t\tauto np = NearestPoint(sg, xy);\n\n\t\t\tfor (size_t i = 0; i < np.size(); i++)\n\t\t\t{\n\t\t\t\tstd::pair, std::vector> w;\n\t\t\t\tw.first.push_back(np[i].first);\n\t\t\t\tw.second.push_back(np[i].second);\n\t\t\t\tws.push_back(w);\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthrow std::bad_typeid();\n\t\t}\n\n\t\tfor (size_t i = 0; i < ws.size(); i++)\n\t\t{\n\t\t\tconst auto& w = ws[i];\n\t\t\tfor (size_t j = 0; j < w.first.size(); ++j)\n\t\t\t{\n\t\t\t\tcoefficients.push_back(Triplet(static_cast(i), static_cast(w.first[j]), w.second[j]));\n\t\t\t}\n\t\t}\n\t}\n\telse\n\t{\n\t\t// compute weights in the interpolation matrix line by line, i.e. point by point on target grid\n\t\tfor (size_t i = 0; i < target.Size(); ++i)\n\t\t{\n\t\t\tstd::pair, std::vector> w;\n\t\t\tswitch (source.Type())\n\t\t\t{\n\t\t\t\tcase kLatitudeLongitude:\n\t\t\t\tcase kRotatedLatitudeLongitude:\n\t\t\t\tcase kStereographic:\n\t\t\t\tcase kLambertConformalConic:\n\t\t\t\tcase kLambertEqualArea:\n\t\t\t\tcase kTransverseMercator:\n\t\t\t\t\tif (method == kBiLinear)\n\t\t\t\t\t{\n\t\t\t\t\t\tw = InterpolationWeights(dynamic_cast(source),\n\t\t\t\t\t\t dynamic_cast(source).XY(target.LatLon(i)));\n\t\t\t\t\t}\n\t\t\t\t\telse if (method == kNearestPoint)\n\t\t\t\t\t{\n\t\t\t\t\t\tauto np = NearestPoint(dynamic_cast(source),\n\t\t\t\t\t\t dynamic_cast(source).XY(target.LatLon(i)));\n\t\t\t\t\t\tw.first.push_back(np.first);\n\t\t\t\t\t\tw.second.push_back(np.second);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tthrow std::bad_typeid();\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase kReducedGaussian:\n\t\t\t\t\tif (method == kBiLinear)\n\t\t\t\t\t{\n\t\t\t\t\t\tw = InterpolationWeights(dynamic_cast(source), target.LatLon(i));\n\t\t\t\t\t}\n\t\t\t\t\telse if (method == kNearestPoint)\n\t\t\t\t\t{\n\t\t\t\t\t\tauto np = NearestPoint(dynamic_cast(source), target.LatLon(i));\n\t\t\t\t\t\tw.first.push_back(np.first);\n\t\t\t\t\t\tw.second.push_back(np.second);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tthrow std::bad_typeid();\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\t// what to throw?\n\t\t\t\t\tthrow std::bad_typeid();\n\t\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tfor (size_t j = 0; j < w.first.size(); ++j)\n\t\t\t{\n\t\t\t\tcoefficients.push_back(Triplet(static_cast(i), static_cast(w.first[j]), w.second[j]));\n\t\t\t}\n\t\t}\n\t}\n\n\titsInterpolation.setFromTriplets(coefficients.begin(), coefficients.end());\n}\n\ntemplate \nvoid area_interpolation::Interpolate(base& source, base& target)\n{\n\tMap> srcValues(source.data.ValuesAsPOD(), source.data.Size(), 1);\n\tMap> trgValues(target.data.ValuesAsPOD(), target.data.Size(), 1);\n\n\ttrgValues = itsInterpolation * srcValues;\n}\n\ntemplate \nsize_t area_interpolation::SourceSize() const\n{\n\treturn itsInterpolation.cols();\n}\n\ntemplate \nsize_t area_interpolation::TargetSize() const\n{\n\treturn itsInterpolation.rows();\n}\n\n// Interpolator member functions\ntemplate \nstd::map> interpolator::cache;\n\ntemplate \nstd::mutex interpolator::interpolatorAccessMutex;\n\ntemplate \nbool interpolator::Insert(const base& source, const base& target, HPInterpolationMethod method)\n{\n\tstd::lock_guard guard(interpolatorAccessMutex);\n\n\tstd::pair> insertValue;\n\n\ttry\n\t{\n\t\tstd::vector hashes{method, source.grid->Hash(), target.grid->Hash()};\n\t\tinsertValue.first = boost::hash_range(hashes.begin(), hashes.end());\n\n\t\t// area_interpolation is already present in cache\n\t\tif (cache.count(insertValue.first) > 0)\n\t\t{\n\t\t\treturn true;\n\t\t}\n\n\t\tinsertValue.second = himan::interpolate::area_interpolation(*source.grid, *target.grid, method);\n\t}\n\tcatch (const std::exception& e)\n\t{\n\t\tstd::cerr << \"Creating interpolation coefficients failed with \" << e.what() << \"\\n\";\n\t\thiman::Abort();\n\t}\n\n\treturn cache.insert(std::move(insertValue)).second;\n}\n\n// template bool interpolator::Insert(const base&, const base&, HPInterpolationMethod);\n// template bool interpolator::Insert(const base&, const base&, HPInterpolationMethod);\n\ntemplate \nbool interpolator::Interpolate(base& source, base& target, HPInterpolationMethod method)\n{\n\tstd::vector hashes{method, source.grid->Hash(), target.grid->Hash()};\n\tauto it = cache.find(boost::hash_range(hashes.begin(), hashes.end()));\n\n\tif (it != cache.end())\n\t{\n\t\ttry\n\t\t{\n\t\t\tit->second.Interpolate(source, target);\n\t\t\treturn true;\n\t\t}\n\t\tcatch (const boost::bad_get& e)\n\t\t{\n\t\t\tstd::cout << e.what() << std::endl;\n\t\t\treturn false;\n\t\t}\n\t}\n\n\telse\n\t{\n\t\tInsert(source, target, method);\n\t\treturn Interpolate(source, target, method);\n\t}\n}\n\n// template bool interpolator::Interpolate(base&, base&, HPInterpolationMethod);\n// template bool interpolator::Interpolate(base&, base&, HPInterpolationMethod);\n\n} // namespace interpolate\n} // namespace himan\n", "meta": {"hexsha": "ed437795b96b1905d846513751ecc54c8d7d1022", "size": 31199, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "himan-lib/source/interpolate.cpp", "max_stars_repo_name": "fmidev/himan", "max_stars_repo_head_hexsha": "481e0cf9a3d15c900e07d08cf7e22de1c50a6823", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18.0, "max_stars_repo_stars_event_min_datetime": "2017-04-20T18:51:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T21:12:49.000Z", "max_issues_repo_path": "himan-lib/source/interpolate.cpp", "max_issues_repo_name": "fmidev/himan", "max_issues_repo_head_hexsha": "481e0cf9a3d15c900e07d08cf7e22de1c50a6823", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2018-07-05T02:15:56.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-01T09:36:51.000Z", "max_forks_repo_path": "himan-lib/source/interpolate.cpp", "max_forks_repo_name": "fmidev/himan", "max_forks_repo_head_hexsha": "481e0cf9a3d15c900e07d08cf7e22de1c50a6823", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-02-18T06:32:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-29T15:17:09.000Z", "avg_line_length": 29.1307189542, "max_line_length": 119, "alphanum_fraction": 0.6406615597, "num_tokens": 9216, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6334102636778401, "lm_q2_score": 0.47268347662043286, "lm_q1q2_score": 0.29940256556230654}} {"text": "/*\n * Copyright (c) 2019, The Regents of the University of California (Regents).\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * 1. Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following\n * disclaimer in the documentation and/or other materials provided\n * with the distribution.\n *\n * 3. Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived\n * from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n *\n * Please contact the author(s) of this library if you have any questions.\n * Authors: David Fridovich-Keil ( dfk@eecs.berkeley.edu )\n */\n\n///////////////////////////////////////////////////////////////////////////////\n//\n// 14D quadrotor dynamics.\n//\n///////////////////////////////////////////////////////////////////////////////\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace quads {\n\nVector14d Quadrotor14D::operator()(const Vector14d& x,\n const Vector4d& u) const {\n ROS_ASSERT(initialized_);\n\n // Precompute sines/consines.\n const double cpsi = std::cos(x(kPsiIdx));\n const double spsi = std::sin(x(kPsiIdx));\n const double cphi = std::cos(x(kPhiIdx));\n const double sphi = std::sin(x(kPhiIdx));\n const double ctheta = std::cos(x(kThetaIdx));\n const double stheta = std::sin(x(kThetaIdx));\n\n const double gx = (cpsi * stheta * cphi + spsi * sphi) / m_;\n const double gy = (spsi * stheta * cphi - cpsi * sphi) / m_;\n const double gz = cphi * ctheta / m_;\n\n Vector14d xdot;\n xdot << x(kDxIdx), x(kDyIdx), x(kDzIdx), x(kQIdx), x(kRIdx), x(kPIdx),\n gx * x(kZetaIdx), gy * x(kZetaIdx), gz * x(kZetaIdx) - 9.81, x(kXiIdx),\n u(0), u(2) / Iy_, u(1) / Ix_, u(3) / Iz_;\n\n return xdot;\n}\n\nMatrix14x14d Quadrotor14D::StateJacobian(const Vector14d& x,\n const Vector4d& u) const {\n const double theta = x(kThetaIdx);\n const double psi = x(kPsiIdx);\n const double phi = x(kPhiIdx);\n const double zeta = x(kZetaIdx);\n\n Matrix14x14d F;\n F << 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,\n zeta * std::cos(phi) * std::cos(psi) * std::cos(theta),\n zeta * (std::cos(phi) * std::sin(psi) -\n std::cos(psi) * std::sin(phi) * std::sin(theta)),\n zeta * (std::cos(psi) * std::sin(phi) -\n std::cos(phi) * std::sin(psi) * std::sin(theta)),\n 0, 0, 0, std::sin(phi) * std::sin(psi) +\n std::cos(phi) * std::cos(psi) * std::sin(theta),\n 0, 0, 0, 0, 0, 0, 0,\n zeta * std::cos(phi) * std::cos(theta) * std::sin(psi),\n -zeta * (std::cos(phi) * std::cos(psi) +\n std::sin(phi) * std::sin(psi) * std::sin(theta)),\n zeta * (std::sin(phi) * std::sin(psi) +\n std::cos(phi) * std::cos(psi) * std::sin(theta)),\n 0, 0, 0, std::cos(phi) * std::sin(psi) * std::sin(theta) -\n std::cos(psi) * std::sin(phi),\n 0, 0, 0, 0, 0, 0, 0, -zeta * std::cos(phi) * std::sin(theta),\n -zeta * std::cos(theta) * std::sin(phi), 0, 0, 0, 0,\n std::cos(phi) * std::cos(theta), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0;\n\n return F;\n}\n\nMatrix6x14d Quadrotor14D::OutputJacobian(const Vector14d& x) const {\n Matrix6x14d H(Matrix6x14d::Zero());\n H(0, 0) = 1.0;\n H(1, 1) = 1.0;\n H(2, 2) = 1.0;\n H(3, 3) = 1.0;\n H(4, 4) = 1.0;\n H(5, 5) = 1.0;\n return H;\n}\n\nbool Quadrotor14D::Initialize(const ros::NodeHandle& n) {\n name_ = ros::names::append(n.getNamespace(), \"quadrotor14d\");\n\n if (!LoadParameters(n)) {\n ROS_ERROR(\"%s: Failed to load parameters.\", name_.c_str());\n return false;\n }\n\n initialized_ = true;\n return true;\n}\n\nbool Quadrotor14D::LoadParameters(const ros::NodeHandle& n) {\n ros::NodeHandle nl(n);\n\n // Mass and inertia.\n if (!nl.getParam(\"dynamics/m\", m_)) return false;\n if (!nl.getParam(\"dynamics/Ix\", Ix_)) return false;\n if (!nl.getParam(\"dynamics/Iy\", Iy_)) return false;\n if (!nl.getParam(\"dynamics/Iz\", Iz_)) return false;\n\n return true;\n}\n\n} // namespace quads\n", "meta": {"hexsha": "631c6ad5c76ed1af457c45c1df0c925662035dbc", "size": 5694, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ros/src/quads/src/quadrotor14d.cpp", "max_stars_repo_name": "HJReachability/learning_feedback_linearization", "max_stars_repo_head_hexsha": "cb655ade4cfbf53f5dd19f79c943f7665666f2cb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-12-18T01:51:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-12T14:49:31.000Z", "max_issues_repo_path": "ros/src/quads/src/quadrotor14d.cpp", "max_issues_repo_name": "HJReachability/learning_feedback_linearization", "max_issues_repo_head_hexsha": "cb655ade4cfbf53f5dd19f79c943f7665666f2cb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-09-19T22:41:50.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-19T22:41:51.000Z", "max_forks_repo_path": "ros/src/quads/src/quadrotor14d.cpp", "max_forks_repo_name": "HJReachability/learning_feedback_linearization", "max_forks_repo_head_hexsha": "cb655ade4cfbf53f5dd19f79c943f7665666f2cb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.96, "max_line_length": 80, "alphanum_fraction": 0.588338602, "num_tokens": 2009, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6334102636778401, "lm_q2_score": 0.47268347662043286, "lm_q1q2_score": 0.29940256556230654}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"Messages_interface.h\"\n#ifdef USE_SURFACE_MESH\n#include \"Kernel_type.h\"\n#include \"Scene_surface_mesh_item.h\"\n#else\n#include \"Scene_polyhedron_item.h\"\n#include \"Polyhedron_type.h\"\n#endif\n#include \"Color_ramp.h\"\n#include \"triangulate_primitive.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace CGAL::Three;\nnamespace PMP = CGAL::Polygon_mesh_processing;\n\n#ifdef USE_SURFACE_MESH\ntypedef Scene_surface_mesh_item Scene_face_graph_item;\n#else\ntypedef Scene_polyhedron_item Scene_face_graph_item;\n#endif\n\ntypedef Scene_face_graph_item::Face_graph Face_graph;\n\n#if defined(CGAL_LINKED_WITH_TBB)\ntemplate \nstruct Distance_computation{\n const AABB_tree& tree;\n const std::vector& sample_points;\n Point_3 initial_hint;\n tbb::atomic* distance;\n std::vector& output;\n\n Distance_computation(const AABB_tree& tree,\n const Point_3 p,\n const std::vector& sample_points,\n tbb::atomic* d,\n std::vector& out )\n : tree(tree)\n , sample_points(sample_points)\n , initial_hint(p)\n , distance(d)\n , output(out)\n {\n }\n void\n operator()(const tbb::blocked_range& range) const\n {\n Point_3 hint = initial_hint;\n double hdist = 0;\n for( std::size_t i = range.begin(); i != range.end(); ++i)\n {\n hint = tree.closest_point(sample_points[i], hint);\n Kernel::FT dist = squared_distance(hint,sample_points[i]);\n double d = CGAL::sqrt(dist);\n output[i] = d;\n if (d>hdist) hdist=d;\n }\n\n if (hdist > distance->load())\n distance->store(hdist);\n }\n};\n#endif\n\nclass Scene_distance_polyhedron_item: public Scene_item\n{\n Q_OBJECT\npublic:\n Scene_distance_polyhedron_item(Face_graph* poly, Face_graph* polyB, QString other_name, int sampling_pts)\n :Scene_item(NbOfVbos,NbOfVaos),\n poly(poly),\n poly_B(polyB),\n are_buffers_filled(false),\n other_poly(other_name)\n {\n nb_pts_per_face = sampling_pts;\n this->setRenderingMode(FlatPlusEdges);\n thermal_ramp.build_thermal();\n }\n bool supportsRenderingMode(RenderingMode m) const {\n return (m == Flat || m == FlatPlusEdges);\n }\n Scene_item* clone() const {return 0;}\n QString toolTip() const {return QString(\"Item %1 with color indicating distance with %2\").arg(this->name()).arg(other_poly);}\n void draw(Viewer_interface *viewer) const\n {\n if(!are_buffers_filled)\n {\n computeElements();\n initializeBuffers(viewer);\n compute_bbox();\n }\n vaos[Facets]->bind();\n attribBuffers(viewer, PROGRAM_WITH_LIGHT);\n program = getShaderProgram(PROGRAM_WITH_LIGHT);\n program->bind();\n program->setUniformValue(\"is_selected\", false);\n viewer->glDrawArrays(GL_TRIANGLES, 0, static_cast(nb_pos/3));\n program->release();\n vaos[Facets]->release();\n }\n void drawEdges(Viewer_interface* viewer) const\n {\n vaos[Edges]->bind();\n\n attribBuffers(viewer, PROGRAM_WITHOUT_LIGHT);\n program = getShaderProgram(PROGRAM_WITHOUT_LIGHT);\n program->bind();\n //draw the edges\n program->setAttributeValue(\"colors\", QColor(Qt::black));\n program->setUniformValue(\"is_selected\", false);\n viewer->glDrawArrays(GL_LINES, 0, static_cast(nb_edge_pos/3));\n vaos[Edges]->release();\n program->release();\n }\n\n void compute_bbox() const {\n _bbox = PMP::bbox(*poly);\n }\n\nprivate:\n Face_graph* poly;\n Face_graph* poly_B;\n mutable bool are_buffers_filled;\n QString other_poly;\n mutable std::vector m_vertices;\n mutable std::vector edge_vertices;\n mutable std::vector normals;\n mutable std::vector colors;\n Color_ramp thermal_ramp;\n int nb_pts_per_face;\n\n enum VAOs {\n Facets=0,\n Edges,\n NbOfVaos};\n\n enum VBOs {\n Vertices=0,\n Edge_vertices,\n Normals,\n Colors,\n NbOfVbos};\n\n mutable std::size_t nb_pos;\n mutable std::size_t nb_edge_pos;\n mutable QOpenGLShaderProgram *program;\n\n //fills 'out' and returns the hausdorff distance for calibration of the color_ramp.\n\n double compute_distances(const Face_graph& m, const std::vector& sample_points,\n std::vector& out)const\n {\n typedef CGAL::AABB_face_graph_triangle_primitive Primitive;\n typedef CGAL::AABB_traits Traits;\n typedef CGAL::AABB_tree< Traits > Tree;\n\n Tree tree( faces(m).first, faces(m).second, m);\n tree.accelerate_distance_queries();\n tree.build();\n boost::graph_traits::vertex_descriptor vd = *(vertices(m).first);\n Traits::Point_3 hint = get(CGAL::vertex_point,*poly, vd);\n\n#if !defined(CGAL_LINKED_WITH_TBB)\n double hdist = 0;\n for(std::size_t i = 0; ihdist) hdist=d;\n }\n return hdist;\n#else\n tbb::atomic distance;\n distance.store(0);\n Distance_computation f(tree, hint, sample_points, &distance, out);\n tbb::parallel_for(tbb::blocked_range(0, sample_points.size()), f);\n return distance;\n#endif\n }\n\n void computeElements()const\n {\n QApplication::setOverrideCursor(Qt::WaitCursor);\n m_vertices.resize(0);\n edge_vertices.resize(0);\n normals.resize(0);\n colors.resize(0);\n\n typedef Kernel::Vector_3\t Vector;\n typedef boost::graph_traits::face_descriptor face_descriptor;\n typedef boost::graph_traits::vertex_descriptor vertex_descriptor;\n\n typedef boost::property_map::type VPmap; \n VPmap vpmap = get(CGAL::vertex_point,*poly);\n\n //facets\n {\n boost::container::flat_map face_normals_map;\n boost::associative_property_map< boost::container::flat_map >\n nf_pmap(face_normals_map);\n boost::container::flat_map vertex_normals_map;\n boost::associative_property_map< boost::container::flat_map >\n nv_pmap(vertex_normals_map);\n\n PMP::compute_normals(*poly, nv_pmap, nf_pmap);\n std::vector total_points(0);\n\n BOOST_FOREACH(boost::graph_traits::face_descriptor f, faces(*poly)) {\n Vector nf = get(nf_pmap, f);\n typedef FacetTriangulator::vertex_descriptor> FT;\n double diagonal;\n if(this->diagonalBbox() != std::numeric_limits::infinity())\n diagonal = this->diagonalBbox();\n else\n diagonal = 0.0;\n\n //compute distance with other polyhedron\n //sample facet\n std::vector sampled_points;\n std::size_t nb_points = (std::max)((int)std::ceil(nb_pts_per_face * PMP::face_area(f,*poly,PMP::parameters::geom_traits(Kernel()))),\n 1);\n Kernel::Point_3 &p = get(vpmap,target(halfedge(f,*poly),*poly));\n Kernel::Point_3 &q = get(vpmap,target(next(halfedge(f,*poly),*poly),*poly));\n Kernel::Point_3 &r = get(vpmap,target(next(next(halfedge(f,*poly),*poly),*poly),*poly));\n CGAL::Random_points_in_triangle_3 g(p, q, r);\n CGAL::cpp11::copy_n(g, nb_points, std::back_inserter(sampled_points));\n sampled_points.push_back(p);\n sampled_points.push_back(q);\n sampled_points.push_back(r);\n\n //triangle facets with sample points for color display\n FT triangulation(f,sampled_points,nf,poly,diagonal);\n\n if(triangulation.cdt->dimension() != 2 )\n {\n qDebug()<<\"Error : cdt not right (dimension != 2). Facet not displayed\";\n continue;\n }\n\n //iterates on the internal faces to add the vertices to the positions\n //and the normals to the appropriate vectors\n\n for(FT::CDT::Finite_faces_iterator\n ffit = triangulation.cdt->finite_faces_begin(),\n end = triangulation.cdt->finite_faces_end();\n ffit != end; ++ffit)\n {\n if(ffit->info().is_external)\n continue;\n\n for (int i = 0; i<3; ++i)\n {\n total_points.push_back(ffit->vertex(i)->point());\n m_vertices.push_back(ffit->vertex(i)->point().x());\n m_vertices.push_back(ffit->vertex(i)->point().y());\n m_vertices.push_back(ffit->vertex(i)->point().z());\n\n normals.push_back(nf.x());\n normals.push_back(nf.y());\n normals.push_back(nf.z());\n }\n }\n }\n //compute the distances\n typedef CGAL::Spatial_sort_traits_adapter_3::type > Search_traits_3;\n\n std::vector distances(total_points.size());\n std::vector indices;\n indices.reserve(total_points.size());\n std::copy(boost::counting_iterator(0),\n boost::counting_iterator(total_points.size()),\n std::back_inserter(indices));\n spatial_sort(indices.begin(),\n indices.end(),\n Search_traits_3(CGAL::make_property_map(total_points)));\n std::vector sorted_points(total_points.size());\n for(std::size_t i = 0; i < sorted_points.size(); ++i)\n {\n sorted_points[i] = total_points[indices[i]];\n }\n\n double hausdorff = compute_distances(*poly_B,\n sorted_points,\n distances);\n //compute the colors\n colors.resize(sorted_points.size()*3);\n for(std::size_t i=0; i::edge_descriptor\tedge_descriptor;\n\n BOOST_FOREACH(edge_descriptor he, edges(*poly)){\n const Point& a = get(vpmap,target(he,*poly));\n const Point& b = get(vpmap,source(he,*poly));\n {\n\n edge_vertices.push_back(a.x());\n edge_vertices.push_back(a.y());\n edge_vertices.push_back(a.z());\n\n edge_vertices.push_back(b.x());\n edge_vertices.push_back(b.y());\n edge_vertices.push_back(b.z());\n }\n }\n }\n QApplication::restoreOverrideCursor();\n }\n void initializeBuffers(Viewer_interface *viewer)const\n {\n\n program = getShaderProgram(PROGRAM_WITH_LIGHT, viewer);\n program->bind();\n vaos[Facets]->bind();\n buffers[Vertices].bind();\n buffers[Vertices].allocate(m_vertices.data(),\n static_cast(m_vertices.size()*sizeof(float)));\n program->enableAttributeArray(\"vertex\");\n program->setAttributeBuffer(\"vertex\",GL_FLOAT,0,3);\n buffers[Vertices].release();\n buffers[Normals].bind();\n buffers[Normals].allocate(normals.data(),\n static_cast(normals.size()*sizeof(float)));\n program->enableAttributeArray(\"normals\");\n program->setAttributeBuffer(\"normals\",GL_FLOAT,0,3);\n buffers[Normals].release();\n buffers[Colors].bind();\n buffers[Colors].allocate(colors.data(),\n static_cast(colors.size()*sizeof(float)));\n program->enableAttributeArray(\"colors\");\n program->setAttributeBuffer(\"colors\",GL_FLOAT,0,3);\n buffers[Colors].release();\n vaos[Facets]->release();\n program->release();\n\n program = getShaderProgram(PROGRAM_WITHOUT_LIGHT, viewer);\n program->bind();\n vaos[Edges]->bind();\n buffers[Edge_vertices].bind();\n buffers[Edge_vertices].allocate(edge_vertices.data(),\n static_cast(edge_vertices.size()*sizeof(float)));\n program->enableAttributeArray(\"vertex\");\n program->setAttributeBuffer(\"vertex\",GL_FLOAT,0,3);\n buffers[Edge_vertices].release();\n vaos[Facets]->release();\n program->release();\n\n nb_pos = m_vertices.size();\n m_vertices.resize(0);\n //\"Swap trick\" insures that the memory is indeed freed and not kept available\n std::vector(m_vertices).swap(m_vertices);\n nb_edge_pos = edge_vertices.size();\n edge_vertices.resize(0);\n std::vector(edge_vertices).swap(edge_vertices);\n normals.resize(0);\n std::vector(normals).swap(normals);\n colors.resize(0);\n std::vector(colors).swap(colors);\n are_buffers_filled = true;\n }\n};\nclass DistancePlugin :\n public QObject,\n public Polyhedron_demo_plugin_interface\n{\n Q_OBJECT\n Q_INTERFACES(CGAL::Three::Polyhedron_demo_plugin_interface)\n Q_PLUGIN_METADATA(IID \"com.geometryfactory.PolyhedronDemo.PluginInterface/1.0\")\n\n typedef Kernel::Point_3 Point_3;\npublic:\n //decides if the plugin's actions will be displayed or not.\n bool applicable(QAction*) const\n {\n return scene->selectionIndices().size() == 2 &&\n qobject_cast(scene->item(scene->selectionIndices().first())) &&\n qobject_cast(scene->item(scene->selectionIndices().last()));\n }\n //the list of the actions of the plugin.\n QList actions() const\n {\n return _actions;\n }\n //this acts like a constructor for the plugin. It gets the references to the mainwindow and the scene, and connects the action.\n void init(QMainWindow* mw, Scene_interface* sc, Messages_interface* mi)\n {\n //gets the reference to the message interface, to display text in the console widget\n this->messageInterface = mi;\n //get the references\n this->scene = sc;\n this->mw = mw;\n //creates the action\n QAction *actionComputeDistance= new QAction(QString(\"Compute Distance Between Polyhedra\"), mw);\n //specifies the subMenu\n actionComputeDistance->setProperty(\"subMenuName\", \"Polygon Mesh Processing\");\n //links the action\n if(actionComputeDistance) {\n connect(actionComputeDistance, SIGNAL(triggered()),\n this, SLOT(createDistanceItems()));\n _actions << actionComputeDistance;\n }\n }\npublic Q_SLOTS:\n void createDistanceItems()\n {\n bool ok = false;\n nb_pts_per_face = QInputDialog::getInt(mw, tr(\"Sampling\"),\n tr(\"Number of points per face:\"),40, 1,2147483647,1, &ok);\n if (!ok)\n return;\n\n //check the initial conditions\n Scene_face_graph_item* itemA = qobject_cast(scene->item(scene->selectionIndices().first()));\n Scene_face_graph_item* itemB = qobject_cast(scene->item(scene->selectionIndices().last()));\n if(! CGAL::is_triangle_mesh(*itemA->polyhedron()) ||\n !CGAL::is_triangle_mesh(*itemB->polyhedron()) ){\n messageInterface->error(QString(\"Distance not computed. (Both polyhedra must be triangulated)\"));\n return;\n }\n QApplication::setOverrideCursor(Qt::WaitCursor);\n Scene_distance_polyhedron_item* new_itemA = new Scene_distance_polyhedron_item(itemA->polyhedron(),itemB->polyhedron(), itemB->name(), nb_pts_per_face);\n Scene_distance_polyhedron_item* new_itemB = new Scene_distance_polyhedron_item(itemB->polyhedron(),itemA->polyhedron(), itemA->name(), nb_pts_per_face);\n itemA->setVisible(false);\n itemB->setVisible(false);\n new_itemA->setName(QString(\"%1 to %2\").arg(itemA->name()).arg(itemB->name()));\n new_itemB->setName(QString(\"%1 to %2\").arg(itemB->name()).arg(itemA->name()));\n scene->addItem(new_itemA);\n scene->addItem(new_itemB);\n QApplication::restoreOverrideCursor();\n }\nprivate:\n int nb_pts_per_face;\n QList _actions;\n Messages_interface* messageInterface;\n //The reference to the scene\n Scene_interface* scene;\n //The reference to the main window\n QMainWindow* mw;\n};\n#include \"Distance_plugin.moc\"\n", "meta": {"hexsha": "e84c3ca690795afc969c96ee7734b894d6c8afc4", "size": 16750, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ext/libigl/external/cgal/src/CGAL_Project/demo/Polyhedron/Plugins/PMP/Distance_plugin.cpp", "max_stars_repo_name": "liminchen/OptCuts", "max_stars_repo_head_hexsha": "cb85b06ece3a6d1279863e26b5fd17a5abb0834d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 187.0, "max_stars_repo_stars_event_min_datetime": "2019-01-23T04:07:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T03:44:58.000Z", "max_issues_repo_path": "ext/libigl/external/cgal/src/CGAL_Project/demo/Polyhedron/Plugins/PMP/Distance_plugin.cpp", "max_issues_repo_name": "xiaoxie5002/OptCuts", "max_issues_repo_head_hexsha": "1f4168fc867f47face85fcfa3a572be98232786f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8.0, "max_issues_repo_issues_event_min_datetime": "2019-03-22T13:27:38.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-18T13:23:23.000Z", "max_forks_repo_path": "ext/libigl/external/cgal/src/CGAL_Project/demo/Polyhedron/Plugins/PMP/Distance_plugin.cpp", "max_forks_repo_name": "xiaoxie5002/OptCuts", "max_forks_repo_head_hexsha": "1f4168fc867f47face85fcfa3a572be98232786f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 34.0, "max_forks_repo_forks_event_min_datetime": "2019-02-13T01:11:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T03:29:40.000Z", "avg_line_length": 35.4872881356, "max_line_length": 156, "alphanum_fraction": 0.6660895522, "num_tokens": 4085, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6334102636778401, "lm_q2_score": 0.47268347662043286, "lm_q1q2_score": 0.29940256556230654}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"datastructs/matrix.h\"\n#include \"datastructs/equations.h\"\n\n\n#include \"polynomials/commutative_polynomial.h\"\n#include \"polynomials/non_commutative_polynomial.h\"\n\n#include \"semirings/commutativeRExp.h\"\n#include \"semirings/float-semiring.h\"\n#include \"semirings/prec-rat-semiring.h\"\n#include \"semirings/tropical-semiring.h\"\n#include \"semirings/pseudo_linear_set.h\"\n#include \"semirings/semilinear_set.h\"\n#include \"semirings/bool-semiring.h\"\n#include \"semirings/why-set.h\"\n#include \"semirings/viterbi-semiring.h\"\n#include \"semirings/maxmin-semiring.h\"\n\n#ifdef USE_LIBFA\n#include \"semirings/lossy-finite-automaton.h\"\n#include \"polynomials/lossy_non_commutative_polynomial.h\"\n#endif\n\n#ifdef USE_GENEPI\n#include \"semirings/semilinSetNdd.h\"\n#endif\n\n#include \"parser.h\"\n\n\n#include \"solvers/newton_generic.h\"\n#include \"solvers/kleene_seminaive.h\"\n#include \"solvers/solver_utils.h\"\n\n#include \"utils/string_util.h\"\n\n\ntemplate class Poly>\nValuationMap call_solver(const std::string solver_name, const GenericEquations &equations,\n const bool scc, const bool iteration_flag, const std::size_t iterations, const bool graphviz_output){\n if(0 == solver_name.compare(\"newtonSymb\")) {\n std::cout << \"Solver: Newton Symbolic\" << std::endl;\n return apply_solver(equations, scc, iteration_flag, iterations, graphviz_output);\n }\n else if(0 == solver_name.compare(\"newtonConc\")) {\n std::cout << \"Solver: Newton Concrete\"<< std::endl;\n return apply_solver(equations, scc, iteration_flag, iterations, graphviz_output);\n }\n else if(0 == solver_name.compare(\"newtonCLDU\")) {\n std::cout << \"Solver: Newton Concrete (LDU)\"<< std::endl;\n return apply_solver(equations, scc, iteration_flag, iterations, graphviz_output);\n }\n else if(0 == solver_name.compare(\"newtonSLDU\")) {\n std::cout << \"Solver: Newton Symbolic (LDU)\"<< std::endl;\n return apply_solver(equations, scc, iteration_flag, iterations, graphviz_output);\n }\n else if(0 == solver_name.compare(\"kleene\")) {\n std::cout << \"Solver: Kleene solver\"<< std::endl;\n return apply_solver(equations, scc, iteration_flag, iterations, graphviz_output);\n }\n else {\n // default-case\n std::cout << \"Solver: Newton Concrete (LDU)\"<< std::endl;\n return apply_solver(equations, scc, iteration_flag, iterations, graphviz_output);\n }\n}\n\nint main(int argc, char* argv[]) {\n\n namespace po = boost::program_options;\n\n po::options_description desc(\"Allowed options\");\n desc.add_options()\n ( \"scc\", \"apply newton method iteratively to strongly connected components of the equation graph\" )\n ( \"help,h\", \"print this help message\" )\n ( \"iterations,i\", po::value(), \"specify the number of newton iterations. Default is number of equations + 1.\" )\n //( \"verbose\", \"enable verbose output\" )\n //( \"debug\", \"enable debug output\" )\n ( \"test\", \"just for testing purposes ... explicit test defined in main()\" )\n ( \"file,f\", po::value(), \"input file\" )\n ( \"float\", \"float semiring\" )\n ( \"rat\", \"semiring of extended rationals (arbitrary precision)\" )\n ( \"bool\", \"boolean semiring\" )\n ( \"why\", \"why semiring\" )\n ( \"maxmin\", \"MaxMin semiring\" )\n ( \"viterbi\", \"Viterbi semiring\" )\n ( \"tropical\", \"tropical semiring over the integers\" )\n ( \"rexp\", \"commutative regular expression semiring\" )\n ( \"slset\", \"explicit semilinear sets semiring, no simplification \" )\n#ifdef USE_GENEPI\n ( \"slsetndd\", po::value(), \"ndd semilinear sets semiring, give plugin name (lash-msdf, mona)\" )\n ( \"n\", po::value(), \"number of variables, used for slsetndd\" )\n#endif\n ( \"mlset\", \"abstraction over semilinear sets\" )\n ( \"vec-simpl\", \"vector simplification only (only semilinear and multilinear sets)\" )\n ( \"lin-simpl\", \"linear set simplification (only semilinear sets)\" )\n ( \"free\", \"free semiring\" )\n ( \"lossy\", \"lossy semiring\" )\n ( \"prefix\", po::value(), \"prefix semiring with given length\")\n ( \"graphviz\", \"create the file graph.dot with the equation graph (NOTE: currently only with option --scc) \" )\n ( \"solver,s\", po::value(), \"solver type (currently: \\\"newtonSymb\\\", \\\"newtonConc\\\", \\\"newtonCLDU\\\", \\\"newtonSLDU\\\", \\\"newtonNumeric\\\" (only for numeric semirings), or \\\"kleene\\\")\" )\n ;\n\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, desc), vm);\n po::notify(vm);\n\n if (vm.count(\"test\")) {\n Newton newton;\n std::vector variables;\n variables.push_back(Var::GetVarId(\"x\"));\n std::cout << \"- newton (cnt-SR):\" << std::endl;\n\n std::vector > polynomials;\n CommutativePolynomial f1 = CommutativePolynomial({\n { SemilinSetExp(Var::GetVarId(\"a\")), CommutativeMonomial{ {Var::GetVarId(\"x\"),Var::GetVarId(\"x\")} } },\n { SemilinSetExp(Var::GetVarId(\"c\")), CommutativeMonomial{} } });\n\n polynomials.push_back(f1);\n\n Matrix result = newton.solve_fixpoint(polynomials, variables, 2);\n std::cout << result << std::endl;\n\n /* auto s1 = CommutativeRExp(Var::GetVarId(\"a\"));\n auto s2 = CommutativeRExp(Var::GetVarId(\"b\"));\n auto m1 = Matrix(1,1,{s1});\n auto m2 = Matrix(1,1,{s2});\n */\n\n // this actually led to a strange bug with the ublas-matrix implementation!!\n /* auto s1 = SemilinSetExp(Var::GetVarId(\"a\"));\n auto s2 = SemilinSetExp(Var::GetVarId(\"b\"));\n auto m1 = Matrix(1,1,{s1});\n auto m2 = Matrix(1,1,{s2});\n\n auto m3 = m1*m2;\n std::cout << m3;\n */\n return 0;\n }\n\n if (vm.count(\"help\")) {\n std::cout << desc << std::endl;\n return 0;\n }\n\n#ifdef USE_GENEPI\n SemilinSetNdd::genepi_init();\n#endif\n\n int iterations=0;\n if (vm.count(\"iterations\"))\n iterations = vm[\"iterations\"].as();\n\n // check if we can do something useful\n if (!vm.count(\"float\") &&\n !vm.count(\"rat\") &&\n !vm.count(\"rexp\") &&\n !vm.count(\"slset\") &&\n#ifdef USE_GENEPI\n !vm.count(\"slsetndd\") &&\n#endif\n !vm.count(\"free\") &&\n !vm.count(\"bool\") &&\n !vm.count(\"why\") &&\n !vm.count(\"tropical\") &&\n !vm.count(\"mlset\") &&\n !vm.count(\"prefix\") &&\n !vm.count(\"lossy\") &&\n !vm.count(\"maxmin\") &&\n !vm.count(\"viterbi\"))\n {\n std::cout << \"Please supply a supported semiring :)\" << std::endl;\n return 0;\n }\n\n std::vector input;\n std::string line;\n if (vm.count(\"file\")) {\n // we are reading the input from the given file\n std::ifstream file;\n file.open(vm[\"file\"].as(), std::ifstream::in);\n if (file.fail()) {\n std::cerr << \"Could not open input file: \" << vm[\"file\"].as() << std::endl;\n }\n while (std::getline(file, line)) {\n input.push_back(line);\n }\n } else {\n // we are reading from stdin\n while (std::getline(std::cin, line)) {\n input.push_back(line);\n }\n }\n\n // join the input into one string\n std::string input_all =\n std::accumulate(input.begin(), input.end(), std::string(\"\"));\n\n Parser p;\n std::string solver_name;\n\n if(vm.count(\"solver\")) {\n solver_name = vm[\"solver\"].as();\n }\n else {\n solver_name = \"newtonConc\"; //seems to be the fastest\n }\n\n\n const auto iter_flag = vm.count(\"iterations\");\n const auto graph_flag = vm.count(\"graphviz\");\n const auto scc_flag = vm.count(\"scc\");\n\n if (vm.count(\"slset\")) {\n auto equations_raw = p.free_parser(input_all);\n auto equations = MakeCommEquationsAndMap(equations_raw, [](const FreeSemiring &c) -> SemilinSetExp {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations.empty()) return EXIT_FAILURE;\n //PrintEquations(equations);\n if (!vm.count(\"vec-simpl\") && !vm.count(\"lin-simpl\")) {\n DMSG(\"A\");\n std::cout << result_string(\n call_solver(solver_name, equations, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n\n } else if (vm.count(\"vec-simpl\") && !vm.count(\"lin-simpl\")) {\n DMSG(\"B\");\n auto equations2 = MapEquations(equations, [](const SemilinearSet<> &s) {\n return SemilinearSetV{s};\n });\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n } else {\n DMSG(\"C\");\n auto equations2 = MapEquations(equations, [](const SemilinearSet<> &s) {\n return SemilinearSetL{s};\n });\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n }\n#ifdef USE_GENEPI\n } else if (vm.count(\"slsetndd\")) {\n SemilinSetNdd::solver_init(vm[\"n\"].as());\n auto equations = p.slsetndd_parser(input_all);\n if (equations.empty()) return EXIT_FAILURE;\n std::cout << result_string(\n call_solver(solver_name, equations, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n SemilinSetNdd::solver_dealloc();\n#endif\n } else if (vm.count(\"mlset\")) {\n\n auto equations_raw = p.free_parser(input_all);\n auto equations = MakeCommEquationsAndMap(equations_raw, [](const FreeSemiring &c) -> SemilinSetExp {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations.empty()) return EXIT_FAILURE;\n if (vm.count(\"vec-simpl\")) {\n auto m_equations = SemilinearToPseudoLinearEquations<\n DummyDivider, SparseVecSimplifier>(equations);\n //PrintEquations(m_equations);\n std::cout << result_string(\n call_solver(solver_name, equations, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n } else {\n auto m_equations = SemilinearToPseudoLinearEquations<\n DummyDivider, DummyVecSimplifier>(equations);\n //PrintEquations(m_equations);\n std::cout << result_string(\n call_solver(solver_name, equations, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n }\n\n } else if (vm.count(\"rexp\")) {\n\n // parse the input into a list of (Var → Polynomial[SR])\n auto equations = p.rexp_parser(input_all);\n if (equations.empty()) return EXIT_FAILURE;\n\n //PrintEquations(equations);\n\n // apply solver to the equations\n std::cout << result_string(\n call_solver(solver_name, equations, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n\n } else if (vm.count(\"free\")) {\n\n // parse the input into a list of (Var → Polynomial[SR])\n\tauto equations = p.free_parser(input_all);\n //auto equations2 = MakeCommEquations(equations);\n //if (equations2.empty()) return EXIT_FAILURE;\n\n// std::cout << result_string(\n// call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n// ) << std::endl;\n#ifdef USE_LIBFA\n } else if (vm.count(\"lossy\")) {\n\n auto equations = p.free_parser(input_all);\n if (equations.empty()) return EXIT_FAILURE;\n\n //PrintEquations(equations);\n auto equations2 = MapEquations(equations, [](const FreeSemiring &c) -> LossyFiniteAutomaton {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n VarId S_1 = equations2[0].first;\n\n NCEquationsBase eq2 = NCEquationsBase(equations2.begin(), equations2.end());\n\n auto approximation = NonCommutativePolynomial::downwardClosureCourcelle(eq2, S_1);\n std::cout << \"dwc:\\t\" << approximation.string() << std::endl;\n std::cout << \"size NFA for DWC:\\t\" << approximation.size() << std::endl;\n std::cout << \"size minimal DFA for DWC:\\t\" << approximation.minimize().size() << std::endl;\n#endif\n } else if (vm.count(\"prefix\")) {\n\n // parse the input into a list of (Var → Polynomial[SR])\n auto equations = p.prefix_parser(input_all, vm[\"prefix\"].as());\n if (equations.empty()) return EXIT_FAILURE;\n\n //PrintEquations(equations);\n\n // apply the newton method to the equations\n //auto result = apply_solver(equations,\n // vm.count(\"scc\"),\n // vm.count(\"iterations\"),\n // iterations,\n // vm.count(\"graphviz\"));\n //std::cout << result_string(result) << std::endl;\n\n //std::cout << result_string(\n // call_solver(solver_name, equations, scc_flag, iter_flag, iterations, graph_flag)\n // ) << std::endl;\n\n } else if (vm.count(\"float\")) {\n auto equations = p.free_parser(input_all);\n //PrintEquations(equations);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> FloatSemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n //PrintEquations(equations);\n //PrintEquations(equations2);\n\n if(0 == solver_name.compare(\"newtonNumeric\")) {\n std::cout << \"Solver: Newton Numeric (Float)\"<< std::endl;\n std::cout << result_string(\n apply_solver(equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n } else {\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n }\n\n\n } else if (vm.count(\"bool\")) {\n auto equations = p.free_parser(input_all);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> BoolSemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n PrintEquations(equations);\n PrintEquations(equations2);\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n\n } else if (vm.count(\"rat\")) {\n auto equations = p.free_parser(input_all);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> PrecRatSemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n //PrintEquations(equations);\n //PrintEquations(equations2);\n\n if(0 == solver_name.compare(\"newtonNumeric\")) {\n std::cout << \"Solver: Newton Numeric (Rat)\"<< std::endl;\n std::cout << result_string(\n apply_solver(equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n } else {\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n }\n }\n else if (vm.count(\"why\")) {\n auto equations = p.free_parser(input_all);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> WhySemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n\n }\n else if (vm.count(\"tropical\")) {\n auto equations = p.free_parser(input_all);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> TropicalSemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n\n }\n else if (vm.count(\"viterbi\")) {\n auto equations = p.free_parser(input_all);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> ViterbiSemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n }\n else if (vm.count(\"maxmin\")) {\n auto equations = p.free_parser(input_all);\n auto equations2 = MakeCommEquationsAndMap(equations, [](const FreeSemiring &c) -> MaxMinSemiring {\n auto srconv = SRConverter();\n return c.Eval(srconv);\n });\n\n if (equations2.empty()) return EXIT_FAILURE;\n\n std::cout << result_string(\n call_solver(solver_name, equations2, scc_flag, iter_flag, iterations, graph_flag)\n ) << std::endl;\n\n }\n\n#ifdef USE_GENEPI\n SemilinSetNdd::genepi_dealloc();\n#endif\n\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "fc0164fbc530852105085ef44dfd4c8f62881dbd", "size": 17468, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "c/src/main.cpp", "max_stars_repo_name": "mschlund/FPsolve", "max_stars_repo_head_hexsha": "4b8fbe87ed4eeac8a53e191aa34c5aa80b6e0490", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2015-01-17T23:30:54.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-13T20:42:54.000Z", "max_issues_repo_path": "c/src/main.cpp", "max_issues_repo_name": "mschlund/FPsolve", "max_issues_repo_head_hexsha": "4b8fbe87ed4eeac8a53e191aa34c5aa80b6e0490", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/src/main.cpp", "max_forks_repo_name": "mschlund/FPsolve", "max_forks_repo_head_hexsha": "4b8fbe87ed4eeac8a53e191aa34c5aa80b6e0490", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2016-02-21T11:13:38.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-11T03:50:09.000Z", "avg_line_length": 36.4676409186, "max_line_length": 198, "alphanum_fraction": 0.6352186856, "num_tokens": 4667, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6893056040203136, "lm_q2_score": 0.43398146480389854, "lm_q1q2_score": 0.29914585573027175}} {"text": "// Software License for MTL\n// \n// Copyright (c) 2007 The Trustees of Indiana University.\n// 2008 Dresden University of Technology and the Trustees of Indiana University.\n// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.\n// All rights reserved.\n// Authors: Peter Gottschling and Andrew Lumsdaine\n// \n// This file is part of the Matrix Template Library\n// \n// See also license.mtl.txt in the distribution.\n\n#ifndef MTL_DOT_INCLUDE\n#define MTL_DOT_INCLUDE\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace mtl { \n\n namespace vector {\n\n\tnamespace detail {\n\t \n\t // Result type of dot product\n\t template \n\t struct dot_result\n\t {\n\t\ttypedef typename Multiplicable::value_type,\n\t\t\t\t\t typename Collection::value_type>::result_type type;\n\t };\n\n\t // Whether or not conjugating first argument\n\t struct without_conj\n\t {\n\t\ttemplate \n\t\tValue operator()(const Value& v) { return v; }\n\t };\n\n\t struct with_conj\n\t {\n\t\ttemplate \n\t\ttypename mtl::sfunctor::conj::result_type\n\t\toperator() (const Value& v)\n\t\t{\n\t\t using mtl::conj;\n\t\t return conj(v);\n\t\t}\n\t };\n\t}\n\n\tnamespace sfunctor {\n\t \n\t template \n\t struct dot_aux\n\t\t: public meta_math::loop1\n\t {\n\t\ttypedef meta_math::loop1 base;\n\t\ttypedef dot_aux next_t;\n\t\t\n\t\ttemplate \n\t\tstatic inline void \n\t\tapply(Value& tmp00, Value& tmp01, Value& tmp02, Value& tmp03, Value& tmp04, \n\t\t Value& tmp05, Value& tmp06, Value& tmp07, \n\t\t const Vector1& v1, const Vector2& v2, Size i, ConjOpt conj_opt)\n\t\t{\n\t\t // vampir_trace<9901> tracer;\n\t\t tmp00+= conj_opt(v1[ i + base::index0 ]) * v2[ i + base::index0 ];\n\t\t next_t::apply(tmp01, tmp02, tmp03, tmp04, tmp05, tmp06, tmp07, tmp00,\n\t\t\t\t v1, v2, i, conj_opt);\n\t\t}\n\t };\n\n\n\t template \n\t struct dot_aux\n\t {\n\t\ttypedef meta_math::loop1 base;\n\t\t\n\t\ttemplate \n\t\tstatic inline void \n\t\tapply(Value& tmp00, Value&, Value&, Value&, Value&, Value&, Value&, Value&, \n\t\t const Vector1& v1, const Vector2& v2, Size i, ConjOpt conj_opt)\n\t\t{\n\t\t tmp00+= conj_opt(v1[ i + base::index0 ]) * v2[ i + base::index0 ];\n\t\t}\n\t };\n\n\n\t template \n\t struct dot\n\t {\n\t\ttemplate \n\t\ttypename detail::dot_result::type\n\t\tstatic inline apply(const Vector1& v1, const Vector2& v2, ConjOpt conj_opt)\n\t\t{\n\t\t MTL_STATIC_ASSERT((Unroll >= 1), \"Unroll size must be at least 1.\");\n\t\t // MTL_STATIC_ASSERT((Unroll <= 8), \"Maximal unrolling is 8.\"); // Might be relaxed in future versions\n\n\t\t vampir_trace<2003> tracer;\n\t\t MTL_THROW_IF(mtl::size(v1) != mtl::size(v2), incompatible_size());\n\t\t typedef typename detail::dot_result::type value_type;\n\t\t \t\t \n# ifdef MTL_WITH_OPENMP \n\t\t value_type dummy, z= math::zero(dummy), result= z;\n\t\t typedef typename mtl::traits::omp_size_type::size_type>::type size_type;\n\t\t size_type i_max= mtl::size(v1), i_block= Unroll * (i_max / Unroll);\n\n\n #pragma omp parallel\n\t\t {\n\n\t\t\tvampir_trace<8001> tracer;\n\t\t\tvalue_type tmp00= z, tmp01= z, tmp02= z, tmp03= z, tmp04= z, tmp05= z, tmp06= z, tmp07= z;\n\n\t\t\t#pragma omp for\n\t\t\tfor (size_type i= 0; i < i_block; i+= Unroll)\n\t\t\t dot_aux<1, Unroll>::apply(tmp00, tmp01, tmp02, tmp03, tmp04, tmp05, tmp06, tmp07, v1, v2, i, conj_opt);\n\n\t\t\t#pragma omp critical\n\t\t\t result+= ((tmp00 + tmp01) + (tmp02 + tmp03)) + ((tmp04 + tmp05) + (tmp06 + tmp07));\n\t\t }\n\t\t for (size_type i= i_block; i < i_max; i++) \n\t\t\tresult+= conj_opt(v1[i]) * v2[i];\n\n\t\t return result;\n# else\n\t\t typedef typename Collection::size_type size_type;\n\n\t\t value_type dummy, z= math::zero(dummy), tmp00= z, tmp01= z, tmp02= z, tmp03= z, tmp04= z,\n\t\t\t tmp05= z, tmp06= z, tmp07= z;\n\t\t size_type i_max= mtl::size(v1), i_block= Unroll * (i_max / Unroll);\n\t\t \n\t\t for (size_type i= 0; i < i_block; i+= Unroll)\n\t\t\tdot_aux<1, Unroll>::apply(tmp00, tmp01, tmp02, tmp03, tmp04, tmp05, tmp06, tmp07, v1, v2, i, conj_opt);\n\t\t \n\t\t for (size_type i= i_block; i < i_max; i++) \n\t\t\ttmp00+= conj_opt(v1[i]) * v2[i];\n\t\t return ((tmp00 + tmp01) + (tmp02 + tmp03)) + ((tmp04 + tmp05) + (tmp06 + tmp07));\n# endif\n\t\t}\n\n\n\t };\n\t}\n\n\ttemplate \n\ttypename detail::dot_result::type\n\tinline dot_simple(const Vector1& v1, const Vector2& v2, ConjOpt conj_opt)\n\t{\n\t vampir_trace<2040> tracer;\n\t typedef typename Collection::size_type size_type;\n\t typedef typename detail::dot_result::type value_type;\n\n\t value_type dummy, s= math::zero(dummy);\n\t for (size_type i= 0, i_max= mtl::size(v1); i < i_max; ++i)\n\t\ts+= conj_opt(v1[i]) * v2[i];\n\t return s;\n\t}\n\n\ttemplate \n\tstruct dot_class\n\t{\n\t typedef typename detail::dot_result::type result_type;\n\t dot_class(const Vector1& v1, const Vector2& v2) : v1(v1), v2(v2) {}\n\n\t operator result_type() const { return sfunctor::dot::apply(v1, v2, ConjOpt()); }\n\t \n\t const Vector1& v1;\n\t const Vector2& v2;\n\t};\n\n\ttemplate \n\tstruct dot_class<1, Vector1, Vector2, ConjOpt>\n\t{\n\t typedef typename detail::dot_result::type result_type;\n\t dot_class(const Vector1& v1, const Vector2& v2) : v1(v1), v2(v2) {}\n\n\t operator result_type() const { return dot_simple(v1, v2, ConjOpt()); }\n\t \n\t const Vector1& v1;\n\t const Vector2& v2;\n\t};\n\t\n\t/// Lazy dot product\n\t/** It is automatically evaluated when (implicitly) converted to result_type which doesn't work in template expressions.\n\t Can be used for source-to-source transformations. **/\n\ttemplate \n\tdot_class<4, Vector1, Vector2, detail::with_conj>\n\tinline lazy_dot(const Vector1& v1, const Vector2& v2)\n\t{\n\t return dot_class<4, Vector1, Vector2, detail::with_conj>(v1, v2);\n\t}\n\n\ttemplate \n\tdot_class\n\tinline lazy_dot(const Vector1& v1, const Vector2& v2)\n\t{\n\t return dot_class(v1, v2);\n\t}\n\n\ttemplate \n\tdot_class<4, Vector1, Vector2, detail::without_conj>\n\tinline lazy_dot_real(const Vector1& v1, const Vector2& v2)\n\t{\n\t return dot_class<4, Vector1, Vector2, detail::without_conj>(v1, v2);\n\t}\n\n\ttemplate \n\tdot_class\n\tinline lazy_dot_real(const Vector1& v1, const Vector2& v2)\n\t{\n\t return dot_class(v1, v2);\n\t}\n\n\t/// Dot product defined as hermitian(v) * w\n\t/** Unrolled four times by default **/\n\ttemplate \n\ttypename detail::dot_result::type\n\tinline dot(const Vector1& v1, const Vector2& v2)\n\t{\n\t // return dot_simple(v1, v2, detail::with_conj());\n\t return sfunctor::dot<4>::apply(v1, v2, detail::with_conj());\n\t}\n\n\t/// Dot product with user-specified unrolling defined as hermitian(v) * w\n\ttemplate \n\ttypename detail::dot_result::type\n\tinline dot(const Vector1& v1, const Vector2& v2)\n\t{\n\t return sfunctor::dot::apply(v1, v2, detail::with_conj());\n\t}\n\t/// Dot product without conjugate defined as trans(v) * w\n\t/** Unrolled four times by default **/\n\ttemplate \n\ttypename detail::dot_result::type\n\tinline dot_real(const Vector1& v1, const Vector2& v2)\n\t{\n\t return sfunctor::dot<4>::apply(v1, v2, detail::without_conj());\n\t}\n\n\t/// Dot product without conjugate with user-specified unrolling defined as trans(v) * w\n\ttemplate \n\ttypename detail::dot_result::type\n\tinline dot_real(const Vector1& v1, const Vector2& v2)\n\t{\n\t return sfunctor::dot::apply(v1, v2, detail::without_conj());\n\t}\n\n\n } // namespace vector\n \n using vector::dot;\n using vector::dot_real;\n using vector::lazy_dot;\n using vector::lazy_dot_real;\n\n} // namespace mtl\n\n#endif // MTL_DOT_INCLUDE\n", "meta": {"hexsha": "029cfa4a2b700f5f0db546e365d4df4ec2163f86", "size": 9407, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "lib/mtl4/boost/numeric/mtl/operation/dot.hpp", "max_stars_repo_name": "spraetor/amdis2", "max_stars_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-04T16:44:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-03T07:26:27.000Z", "max_issues_repo_path": "lib/mtl4/boost/numeric/mtl/operation/dot.hpp", "max_issues_repo_name": "spraetor/amdis2", "max_issues_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/mtl4/boost/numeric/mtl/operation/dot.hpp", "max_forks_repo_name": "spraetor/amdis2", "max_forks_repo_head_hexsha": "53c45c81a65752a8fafbb54f9ae6724a86639dcd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.970260223, "max_line_length": 121, "alphanum_fraction": 0.6680131817, "num_tokens": 2693, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6224593312018546, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.29907843659445144}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"../src/edmonds_optimum_branching.hpp\"\n#include \"boost/tuple/tuple.hpp\"\n#include \n#include \nusing boost::tuple;\nusing namespace std;\nusing namespace boost;\n\n#ifdef DEBUG\n#define DEBUG_MSG(str) do { std::cout << str << std::endl; } while( false )\n#else\n#define DEBUG_MSG(str) do { } while ( false )\n#endif\n\n// definitions of a complete graph that implements the EdgeListGraph\n// concept of Boost's graph library.\nnamespace boost {\n\tstruct complete_graph {\n\t\tcomplete_graph(int n_vertices) : n_vertices(n_vertices) {}\n\t\tint n_vertices;\n\t\t\n\t\tstruct edge_iterator : public input_iterator_helper\n\t\t{\n\t\t\tint edge_idx, n_vertices;\n\t\t\tedge_iterator() : edge_idx(0), n_vertices(-1) {}\n\t\t\tedge_iterator(int n_vertices, int edge_idx) : edge_idx(edge_idx), n_vertices(n_vertices) {}\n\t\t\tedge_iterator &operator++()\n\t\t\t{\n\t\t\t\tif (edge_idx >= n_vertices * n_vertices)\n\t\t\t\t\treturn *this;\n\t\t\t\t++edge_idx;\n\t\t\t\tif (edge_idx / n_vertices == edge_idx % n_vertices)\n\t\t\t\t\t++edge_idx;\n\t\t\t\treturn *this;\n\t\t\t}\n\t\t\tint operator*() const {return edge_idx;}\n\t\t\tbool operator==(const edge_iterator &iter) const\n\t\t\t{\n\t\t\t\treturn edge_idx == iter.edge_idx;\n\t\t\t}\n\t\t};\n\t};\n\t\n\ttemplate<>\n\tstruct graph_traits {\n\t\ttypedef int vertex_descriptor;\n\t\ttypedef int edge_descriptor;\n\t\ttypedef directed_tag directed_category;\n\t\ttypedef disallow_parallel_edge_tag edge_parallel_category;\n\t\ttypedef edge_list_graph_tag traversal_category;\n\t\ttypedef complete_graph::edge_iterator edge_iterator;\n\t\ttypedef unsigned edges_size_type;\n\t\t\n\t\tstatic vertex_descriptor null_vertex() {return -1;}\n\t};\n\n\tpair\n\tedges(const complete_graph &g)\n\t{\n\t\treturn make_pair(complete_graph::edge_iterator(g.n_vertices, 1),\n\t\t\t\t\t\t complete_graph::edge_iterator(g.n_vertices, g.n_vertices*g.n_vertices));\n\t}\n\t\n\tunsigned\n\tnum_edges(const complete_graph &g)\n\t{\n\t\treturn (g.n_vertices - 1) * (g.n_vertices - 1);\n\t}\n\t\n\tint\n\tsource(int edge, const complete_graph &g)\n\t{\n\t\treturn edge / g.n_vertices;\n\t}\n\t\n\tint\n\ttarget(int edge, const complete_graph &g)\n\t{\n\t\treturn edge % g.n_vertices;\n\t}\n}\n\ntypedef graph_traits::edge_descriptor Edge;\ntypedef graph_traits::vertex_descriptor Vertex;\n\n\nint dirMST(string fin,string fout,string mode)\n{\n\tint n_vertices;\n\tvector< tuple > edge_list;\n\ttuple g_edge;\n\n\tstring line;\n\tint v1,v2,ctr = 0;\n\tfloat weight;\n\tifstream inputf (fin.c_str());\n\tfloat* nodeWeights = NULL;\n\tif(inputf.is_open())\n\t{\n\t\tgetline(inputf,line);\n\t\tsscanf(line.c_str(),\"%d\",&n_vertices);\n\t\tnodeWeights = new float[n_vertices];\n\t\tint ctr = 0;\n\t\twhile(getline(inputf,line))\n\t\t{\n\t\t\tif(ctr weights(extents[n_vertices][n_vertices]);\n\tvector parent(n_vertices);\n\t//Vertex roots[] = {0, 1};\n\tVertex* roots = new Vertex[n_vertices];\n\tfor(int vi = 0;vi branching;\n\t//Initialize all weights to 0\n\tfor(int i=0;i::max();\n\t\t\telse//Maximum spanning tree\n\t\t\t\tweights[i][j] = numeric_limits::min();\n\t\t}\n\t}\n\n\t//Write out the indices of the edge set that form the directed spanning tree\n\tnumeric::ublas::mapped_matrix index_map (n_vertices,n_vertices);\n\tDEBUG_MSG(\"---Graph Read---\\nN: \"<(g_edge);\n\t\tv2 = get<1>(g_edge);\n\t\tweight=get<2>(g_edge);\n\t\tDEBUG_MSG(v1<<\" | \"< MinST\n\t\t//TOptimum isMaximum set to true -> MaxST\n\t}\n\tvector< vector< Edge > > rooted_branching(n_vertices);\n\n\tdouble optVal = numeric_limits::max();\n\tif(isMax)\t\n\t\toptVal = numeric_limits::min();\n\tint optRoot= -1;\n\tdouble branchingWeight;\n\tfor(int vi=0;vi\n\t\t\t(g, identity_property_map(), weights.origin(),\n\t\t\t roots+vi, roots + vi+1, back_inserter(rooted_branching[vi]));\n\t\t}\n\t\telse\n\t\t{\n\t\tedmonds_optimum_branching\n\t\t\t(g, identity_property_map(), weights.origin(),\n\t\t\t roots+vi, roots + vi+1, back_inserter(rooted_branching[vi]));\n\t\t}\n\t\t//Track the weight of the branching\t\n\t\tbranchingWeight = nodeWeights[vi];\n\t\tBOOST_FOREACH(Edge e,rooted_branching[vi])\n\t\t{\n\t\t\tbranchingWeight += weights[source(e, g)][target(e, g)];\n\t\t}\n\t\t//Track the max/min branching weight\n\t\tif(isMax && branchingWeight>optVal)\t\n\t\t{\n\t\t\toptVal = branchingWeight;\n\t\t\toptRoot = vi;\n\t\t}\n\t\tif(!isMax && branchingWeight\"< \\n\";\n\t\texit(1);\n\t}\n\tstring mode = string(argv[3]);\n\tif(mode.compare(\"min\")==0 || mode.compare(\"max\")==0)//strcmp(argv[3],\"min\")==0 || strcmp(argv[3],\"max\"){\n\t{\n\t\treturn dirMST(argv[1],argv[2],mode);\n\t}\n\telse\n\t{\n\t\tcerr<<\"Final argument not or \"<\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define REP(i, n) for(int i = 0, i##_MACRO = (n); i < i##_MACRO; i++)\n#define RANGE(i, a, b) for(int i = (a), i##_MACRO = (b); i < i##_MACRO; i++)\n#define EACH(e, a) for(auto&& e : a)\n#define ALL(a) std::begin(a), std::end(a)\n#define RALL(a) std::rbegin(a), std::rend(a)\n#define FILL(a, n) memset((a), n, sizeof(a))\n#define FILLZ(a) FILL(a, 0)\n#define INT(x) (static_cast(x))\n#define PRECISION(x) std::fixed << std::setprecision(x)\n\nusing namespace std;\n\nusing ll = long long;\nusing VI = std::vector;\nusing VI2D = std::vector>;\nusing VLL = std::vector;\nusing VLL2D = std::vector>;\n\nconstexpr int INF = 2e9;\nconstexpr double EPS = 1e-10;\nconstexpr double PI = acos(-1.0);\n\nconstexpr int dx[] = {-1, 0, 1, 0};\nconstexpr int dy[] = {0, -1, 0, 1};\n\ntemplate \nstruct make_vector_type {\n\tusing type =\n\t\ttypename std::vector::type>;\n};\n\ntemplate \nstruct make_vector_type {\n\tusing type = typename std::vector;\n};\n\ntemplate \nauto make_vector_impl(const std::vector& ls, T init_value) {\n\tif constexpr(N == 0) {\n\t\treturn std::vector(ls[N], init_value);\n\t} else {\n\t\treturn typename make_vector_type::type(\n\t\t\tls[N], make_vector_impl(ls, init_value));\n\t}\n}\n\ntemplate \nauto make_vector(const std::size_t (&ls)[N], T init_value) {\n\tstd::vector dimensions(N);\n\tfor(int i = 0; i < N; i++) {\n\t\tdimensions[N - i - 1] = ls[i];\n\t}\n\treturn make_vector_impl(dimensions, init_value);\n}\n\ntemplate \nstd::vector make_vector(std::size_t size, T init_value) {\n\treturn std::vector(size, init_value);\n}\n\ntemplate \nconstexpr int sign(T x) {\n\treturn x < 0 ? -1 : x > 0 ? 1 : 0;\n}\n\ntemplate <>\nconstexpr int sign(double x) {\n\treturn x < -EPS ? -1 : x > EPS ? 1 : 0;\n}\n\ntemplate \nconstexpr void chmax(T& m, U x) {\n\tm = max(m, x);\n}\n\ntemplate \nconstexpr void chmin(T& m, U x) {\n\tm = min(m, x);\n}\n\ntemplate \nconstexpr T square(T x) {\n\treturn x * x;\n}\n\nconstexpr double deg_to_rad(double deg) {\n\treturn PI * deg / 180.0;\n}\n\nconstexpr double rad_to_deg(double rad) {\n\treturn rad * 180 / PI;\n}\n\n// 二次元ベクトルクラス\nclass Vec2d {\n\tdouble _x;\n\tdouble _y;\n\n\tpublic:\n\t// 原点の位置ベクトル\n\tstatic Vec2d origin() { return Vec2d(0.0, 0.0); }\n\n\t// ゼロベクトル\n\tstatic Vec2d zero() { return Vec2d::origin(); }\n\n\tVec2d(double a, double b) : _x(a), _y(b) {}\n\n\tdouble x() const { return this->_x; }\n\tdouble y() const { return this->_y; }\n\n\t// 外積\n\tdouble det(const Vec2d& rhs) const {\n\t\treturn this->x() * rhs.y() - this->y() * rhs.x();\n\t}\n\n\t// 内積\n\tdouble dot(const Vec2d& rhs) const {\n\t\treturn this->x() * rhs.x() + this->y() * rhs.y();\n\t}\n\n\t// 長さ\n\tdouble length() const { return this->distance(Vec2d::origin()); }\n\n\t// 2つの位置ベクトル間のユークリッド距離\n\tdouble distance(const Vec2d& rhs) const {\n\t\treturn std::sqrt(square(this->x() - rhs.x()) +\n\t\t\t\t\t\t square(this->y() - rhs.y()));\n\t}\n\n\t// 2つの位置ベクトル間のマンハッタン距離\n\tdouble manhattan_distance(const Vec2d& rhs) const {\n\t\treturn std::abs(this->x() - rhs.x()) + std::abs(this->y() - rhs.y());\n\t}\n\n\t// ベクトルとx軸のなす角\n\tdouble argument() const { return std::atan2(this->y(), this->x()); }\n\n\t// 反時計回りに回転したベクトル\n\tVec2d rotate(double rad) const {\n\t\tdouble xx = this->x();\n\t\tdouble yy = this->y();\n\t\treturn Vec2d(xx * cos(rad) - yy * sin(rad),\n\t\t\t\t\t xx * sin(rad) + yy * cos(rad));\n\t}\n\n\t// 単位ベクトル\n\tVec2d unit() const {\n\t\tdouble len = this->length();\n\t\treturn Vec2d(this->x() / len, this->y() / len);\n\t}\n\n\t// 法線ベクトル\n\tVec2d normal() const {\n\t\tdouble len = this->length();\n\t\treturn Vec2d(this->y() / len, -this->x() / len);\n\t}\n\n\t// 平行判定\n\tbool is_parallel(const Vec2d& rhs) const { return false; }\n\n\t// ベクトル和\n\tVec2d operator+() const { return *this; }\n\tVec2d operator+(const Vec2d& rhs) const {\n\t\treturn Vec2d(this->x() + rhs.x(), this->y() + rhs.y());\n\t}\n\n\t// ベクトル差\n\tVec2d operator-() const { return Vec2d(-this->x(), -this->y()); }\n\tVec2d operator-(const Vec2d& rhs) const {\n\t\treturn Vec2d(this->x() - rhs.x(), this->y() - rhs.y());\n\t}\n\n\t// スカラー積\n\tVec2d operator*(const double rhs) const {\n\t\treturn Vec2d(this->x() * rhs, this->y() * rhs);\n\t}\n\tVec2d operator/(const double rhs) const {\n\t\treturn Vec2d(this->x() / rhs, this->y() / rhs);\n\t}\n\n\tbool operator<(const Vec2d& rhs) const {\n\t\treturn sign(this->x()) ? this->y() < rhs.y() : this->x() < rhs.x();\n\t}\n\n\tprivate:\n};\n\nint main() {\n\tint n, x0, y0, xharf, yharf;\n\tcin >> n;\n\tcin >> x0 >> y0;\n\tcin >> xharf >> yharf;\n\n\tVec2d p0 = {x0, y0};\n\tVec2d ph = {xharf, yharf};\n\n\tVec2d center = (p0 + ph) / 2;\n\tVec2d c_to_p0 = p0 - center;\n\tVec2d c_to_pr = c_to_p0.rotate(PI * 2 / n);\n\tVec2d result = center + c_to_pr;\n\n\tcout << PRECISION(15) << result.x() << \" \" << result.y() << endl;\n\treturn 0;\n}\n", "meta": {"hexsha": "a8630a3f940764d4ac696bb003411f977f47f141", "size": 5274, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "AtCoder/ABC197/D.cpp", "max_stars_repo_name": "arlechann/atcoder", "max_stars_repo_head_hexsha": "1af08efa6d3a0e8c75e4eaf13e1eda994820b9e2", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "AtCoder/ABC197/D.cpp", "max_issues_repo_name": "arlechann/atcoder", "max_issues_repo_head_hexsha": "1af08efa6d3a0e8c75e4eaf13e1eda994820b9e2", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "AtCoder/ABC197/D.cpp", "max_forks_repo_name": "arlechann/atcoder", "max_forks_repo_head_hexsha": "1af08efa6d3a0e8c75e4eaf13e1eda994820b9e2", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.0305676856, "max_line_length": 76, "alphanum_fraction": 0.6230565036, "num_tokens": 1828, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.299044887348973}} {"text": "#include \"MapsMesh.h\"\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace Maps {\n\ntemplate \nstatic void OpenMesh2IGL(const Mesh *mesh, Eigen::MatrixX3d &V, Eigen::MatrixX3i &F) {\n\n assert(mesh->is_trimesh());\n\n auto verticesCount = std::distance(mesh->vertices_sbegin(), mesh->vertices_end());\n auto facesCount = std::distance(mesh->faces_sbegin(), mesh->faces_end());\n V.resize(verticesCount, 3);\n F.resize(facesCount, 3);\n\n std::map newVertexHandleMap;\n int j = 0;\n for (auto i = mesh->vertices_sbegin(); i != mesh->vertices_end(); i++, j++) {\n auto p = mesh->point(*i);\n V(j, 0) = p[0];\n V(j, 1) = p[1];\n V(j, 2) = p[2];\n newVertexHandleMap[*i] = j;\n }\n\n j = 0;\n for (auto i = mesh->faces_sbegin(); i != mesh->faces_end(); i++, j++) {\n auto fh = *i;\n int vi = 0;\n for (typename Mesh::ConstFaceVertexCCWIter fvi = mesh->cfv_ccwbegin(fh);\n vi < 3 && fvi != mesh->cfv_ccwend(fh); ++fvi) {\n F(j, vi) = newVertexHandleMap[*fvi];\n vi++;\n }\n }\n}\n\nint MapMesh::CDTTrangle(const Coordinate2DPair &coordinates,\n std::vector> &faces,\n BaryCoor &barycentricCoordinates) {\n\n faces.clear();\n\n std::vector points(coordinates.size());\n for (int i = 0; i < coordinates.size(); i++) {\n double x = coordinates[i].second[0];\n double y = coordinates[i].second[1];\n\n points[i] = new p2t::Point(x, y);\n }\n\n p2t::CDT cdt(points);\n\n try {\n cdt.Triangulate();\n } catch (const std::runtime_error &exception) {\n std::cout << exception.what() << std::endl;\n throw exception;\n }\n\n auto triangles = cdt.GetTriangles();\n if (!p2t::IsDelaunay(triangles)) {\n return -1;\n }\n\n int trangleIdx = -1;\n for (int j = 0; j < triangles.size(); j++) {\n auto &triangle = triangles[j];\n std::array triangle2D;\n triangle2D[0] = Point2D(triangle->GetPoint(0)->x, triangle->GetPoint(0)->y);\n triangle2D[1] = Point2D(triangle->GetPoint(1)->x, triangle->GetPoint(1)->y);\n triangle2D[2] = Point2D(triangle->GetPoint(2)->x, triangle->GetPoint(2)->y);\n\n std::array face;\n for (int i = 0; i < 3; i++) {\n auto position = std::find(points.begin(), points.end(), triangle->GetPoint(i));\n if (position == points.end()) return -1;\n face[i] = coordinates[position - points.begin()].first;\n }\n faces.push_back(face);\n\n /**\n * 计算原点的重心坐标\n */\n\n if (!IsInTriangle(Point2D(0, 0), triangle2D)) continue;\n\n auto [alpha, beta, gamma] = CalculateBaryCoor(Point2D(0, 0), triangle2D);\n barycentricCoordinates[0] = std::make_pair(face[0], alpha);\n barycentricCoordinates[1] = std::make_pair(face[1], beta);\n barycentricCoordinates[2] = std::make_pair(face[2], gamma);\n trangleIdx = j;\n }\n\n for (auto &point : points) {\n delete point;\n }\n\n return trangleIdx;\n}\n\nint MapMesh::MVTTrangle(const Coordinate2DPair &coordinates, int startIdx,\n std::vector> &faces,\n BaryCoor &barycentricCoordinates) {\n faces.clear();\n int trangleIdx = -1;\n for (size_t i = 0, ii = 1; i < coordinates.size(); i++, ii++, ii %= coordinates.size()) {\n if (i == startIdx || ii == startIdx) continue;\n\n std::array face(\n {coordinates[i].first, coordinates[ii].first, coordinates[startIdx].first});\n\n faces.push_back(face);\n\n std::array triangle;\n triangle[0] = coordinates[startIdx].second;\n triangle[1] = coordinates[i].second;\n triangle[2] = coordinates[ii].second;\n\n /**\n * 计算原点的重心坐标\n */\n\n if (!IsInTriangle(Point2D(0, 0), triangle)) continue;\n\n auto [alpha, beta, gamma] = CalculateBaryCoor(Point2D(0, 0), triangle);\n barycentricCoordinates[0] = std::make_pair(coordinates[startIdx].first, alpha);\n barycentricCoordinates[1] = std::make_pair(coordinates[i].first, beta);\n barycentricCoordinates[2] = std::make_pair(coordinates[ii].first, gamma);\n\n trangleIdx = static_cast(faces.size() - 1);\n }\n return trangleIdx;\n}\n\nstd::optional MapMesh::ReCalculate2DCoordinates(\n std::map &originCoor, VertexHandle deleteVertex) const {\n if (!IsVertexDeleted(deleteVertex)) return std::nullopt;\n auto baryCoor = data(deleteVertex).baryCoor.value();\n\n return originCoor[baryCoor[0].first] * baryCoor[0].second +\n originCoor[baryCoor[1].first] * baryCoor[1].second +\n originCoor[baryCoor[2].first] * baryCoor[2].second;\n}\n\nvoid MapMesh::ReTrangleAndAddFace(const VertexHandle &deleteVertex) {\n // 记录1领域面中所有包含的点, 并更新这些点的参数\n // 假设1领域面f上记录了一个点v, v中记录了v在f上的重心坐标(a, b, c), 面f在经过2维映射变成了f'\n // 更新过程: 1. 根据f'和(a, b, c)计算v的二维映射点v'\n // 2. 重新计算包含v'的三角形p‘, 并根据p’重新计算坐标(a', b', c')\n // 3. 删除f, 添加面p, 更新v的重心坐标, 建立p与v的关联\n\n std::vector ringFaces(vf_begin(deleteVertex), vf_end(deleteVertex));\n Coordinate2DPair coordinates;\n Calculate2D(deleteVertex, coordinates);\n\n // 重新计算1领域面上所有包含的点的二维坐标\n std::map currentPoint2DMap(coordinates.begin(), coordinates.end());\n std::map deletePoint2DMap;\n for (auto &face : ringFaces) {\n for (auto &vertex : data(face).vertrices) {\n auto newCoor = ReCalculate2DCoordinates(currentPoint2DMap, vertex);\n if (!newCoor.has_value()) break;\n deletePoint2DMap[vertex] = newCoor.value();\n }\n }\n\n delete_vertex(deleteVertex, false);\n\n BaryCoor barycentricCoordinates;\n std::vector> newFaces;\n\n int trangleIdx = CDTTrangle(coordinates, newFaces, barycentricCoordinates);\n std::vector facesHandle;\n if (trangleIdx != -1 && TryToAddFaces(newFaces, facesHandle)) {\n data(facesHandle[trangleIdx]).vertrices.push_back(deleteVertex);\n data(deleteVertex).baryCoor = barycentricCoordinates;\n\n // 判断被删除的点在那个三角形内部, 并计算重心坐标\n\n for (auto &[vertex, point2D] : deletePoint2DMap) {\n auto newParma = UpdateParam(newFaces, currentPoint2DMap, point2D);\n if (!newParma.has_value()) continue;\n auto [idx, alpha, beta, gamma] = newParma.value();\n data(facesHandle[idx]).vertrices.push_back(vertex);\n\n BaryCoor baryCoor;\n baryCoor[0].first = newFaces[idx][0], baryCoor[0].second = alpha;\n baryCoor[1].first = newFaces[idx][1], baryCoor[1].second = beta;\n baryCoor[2].first = newFaces[idx][2], baryCoor[2].second = gamma;\n data(vertex).baryCoor = baryCoor;\n }\n\n return;\n }\n for (int i = 0; i < coordinates.size(); i++) {\n newFaces.clear();\n trangleIdx = MVTTrangle(coordinates, i, newFaces, barycentricCoordinates);\n if (TryToAddFaces(newFaces, facesHandle)) {\n\n data(facesHandle[trangleIdx]).vertrices.push_back(deleteVertex);\n data(deleteVertex).baryCoor = barycentricCoordinates;\n\n for (auto &[vertex, point2D] : deletePoint2DMap) {\n auto newParma = UpdateParam(newFaces, currentPoint2DMap, point2D);\n if (!newParma.has_value()) continue;\n auto [idx, alpha, beta, gamma] = newParma.value();\n data(facesHandle[idx]).vertrices.push_back(vertex);\n\n BaryCoor baryCoor;\n baryCoor[0].first = newFaces[idx][0], baryCoor[0].second = alpha;\n baryCoor[1].first = newFaces[idx][1], baryCoor[1].second = beta;\n baryCoor[2].first = newFaces[idx][2], baryCoor[2].second = gamma;\n data(vertex).baryCoor = baryCoor;\n }\n return;\n }\n }\n throw std::runtime_error(\"can't add face\");\n}\n\nvoid MapMesh::Initialize() {\n originFaces = std::vector(faces_sbegin(), faces_end());\n for (const auto &face : originFaces) {\n originFaceVertices[face] = std::vector(fv_begin(face), fv_end(face));\n }\n}\n\nvoid MapMesh::CalculateCurvature() {\n Eigen::MatrixX3d V;\n Eigen::MatrixX3i F;\n Eigen::VectorXd K;\n\n OpenMesh2IGL(this, V, F);\n igl::gaussian_curvature(V, F, K);\n\n int j = 0;\n maxCurvature = (std::numeric_limits::min)();\n for (auto i = vertices_sbegin(); i != vertices_end(); i++, j++) {\n data(*i).curvature = K[j];\n if (K[j] > maxCurvature) {\n maxCurvature = K[j];\n }\n }\n}\n\nvoid MapMesh::CalculateWeight(double lambda) {\n while (!curvatureQueue.empty()) {\n curvatureQueue.pop();\n }\n\n for (auto i = vertices_sbegin(); i != vertices_end(); i++) {\n data(*i).weight = lambda * data(*i).curvature / maxCurvature +\n (1 - lambda) * data(*i).ringArea / maxRingArea;\n curvatureQueue.push(*i);\n }\n}\n\nvoid MapMesh::CalculateAreas() {\n maxRingArea = (std::numeric_limits::min)();\n for (auto faceIter = faces_sbegin(); faceIter != faces_end(); faceIter++) {\n double area = CalculateArea(*faceIter);\n data(*faceIter).area = area;\n }\n\n for (auto vertexIter = vertices_sbegin(); vertexIter != vertices_end(); vertexIter++) {\n double ringArea = 0;\n for (auto faceIter = vf_begin(*vertexIter); faceIter != vf_end(*vertexIter); faceIter++) {\n ringArea += data(*faceIter).area;\n }\n if (ringArea > maxRingArea) {\n maxRingArea = ringArea;\n }\n data(*vertexIter).ringArea = ringArea;\n }\n}\n\nvoid MapMesh::MapFaceFromOriginMesh(const FaceHandle &face, std::array &mapFace) const {\n if (originFaceVertices.find(face) == originFaceVertices.end()) return;\n\n const std::vector &vertices = originFaceVertices.at(face);\n assert(vertices.size() == 3);\n for (int i = 0; i < 3; i++) {\n auto vertexHandle = vertices[i];\n if (!IsVertexDeleted(vertexHandle)) {\n mapFace[i] = point(vertexHandle);\n continue;\n }\n\n auto baryCoor = data(vertexHandle).baryCoor.value();\n mapFace[i] = point(baryCoor[0].first) * baryCoor[0].second +\n point(baryCoor[1].first) * baryCoor[1].second +\n point(baryCoor[2].first) * baryCoor[2].second;\n }\n}\n\nvoid MapMesh::FaceSubDivision() {\n std::vector originFaceHandle(faces_sbegin(), faces_end());\n\n for (const auto &faceHandle : originFaceHandle) {\n std::vector vertices(fv_begin(faceHandle), fv_end(faceHandle));\n assert(vertices.size() == 3);\n\n for (int i = 0, ii = 1; i < 3; i++, ii++, ii %= 3) {\n auto newPoint = (point(vertices[i]) + point(vertices[ii])) / 2.0;\n auto newPointHandle = add_vertex(newPoint);\n data(newPointHandle).isNew = true;\n vertices.push_back(newPointHandle);\n }\n delete_face(faceHandle);\n add_face({vertices[0], vertices[3], vertices[5]});\n add_face({vertices[3], vertices[1], vertices[4]});\n add_face({vertices[5], vertices[4], vertices[2]});\n add_face({vertices[3], vertices[4], vertices[5]});\n }\n}\n\nvoid MapMesh::DownSampling() {\n request_face_status();\n request_vertex_status();\n request_edge_status();\n\n for (auto vertexIter = vertices_sbegin(); vertexIter != vertices_end(); vertexIter++) {\n data(*vertexIter).canBeDeleted = true;\n }\n\n CalculateCurvature();\n CalculateAreas();\n CalculateWeight(0.5);\n while (!curvatureQueue.empty()) {\n auto vertexHandle = curvatureQueue.top();\n curvatureQueue.pop();\n if (!data(vertexHandle).canBeDeleted) continue;\n\n for (auto ringVertex = vv_begin(vertexHandle); ringVertex != vv_end(vertexHandle);\n ringVertex++) {\n data(*ringVertex).canBeDeleted = false;\n }\n\n ReTrangleAndAddFace(vertexHandle);\n }\n SaveBaseLevelMesh();\n}\n\nvoid MapMesh::Remesh() {\n\n int N = static_cast(std::distance(vertices_sbegin(), vertices_end()));\n progressbar bar(N);\n\n std::mutex _mutex;\n\n auto IsMapedInASingleFace = [&](const FaceHandle &faceHandle) -> bool {\n std::set verticesHandle;\n for (const auto &vertexHandle : originFaceVertices[faceHandle]) {\n if (data(vertexHandle).baryCoor.has_value()) {\n auto baryCoor = data(vertexHandle).baryCoor.value();\n verticesHandle.insert(baryCoor[0].first);\n verticesHandle.insert(baryCoor[1].first);\n verticesHandle.insert(baryCoor[2].first);\n } else {\n verticesHandle.insert(vertexHandle);\n }\n }\n\n return verticesHandle.size() == 3;\n };\n\n auto findMaxCommonVertex = [&](const std::vector &facesHandle) {\n std::multiset verticesHandle;\n for (const auto &faceHandle : facesHandle) {\n for (const auto &vertexHandle : baseLevelMesh->fv_range(faceHandle)) {\n verticesHandle.insert(vertexHandle);\n }\n }\n\n VertexHandle maxCommonVertex;\n int maxCount = -1;\n for (const auto &vertex : verticesHandle) {\n int count = static_cast(verticesHandle.count(vertex));\n if (count > maxCount) {\n maxCount = static_cast(verticesHandle.count(vertex));\n maxCommonVertex = vertex;\n }\n }\n\n return maxCommonVertex;\n };\n\n auto isRingFace = [&](const VertexHandle &vertexHandle, const FaceHandle &faceHandle) {\n for (const auto &face : baseLevelMesh->vf_range(vertexHandle)) {\n if (face == faceHandle) return true;\n }\n return false;\n };\n\n auto isRingPoint =\n [&](const VertexHandle &vertexHandle, const std::vector &ringVertices) {\n for (const auto &ringVertex : ringVertices) {\n bool found = false;\n for (const auto &realRingVertex : baseLevelMesh->vv_range(vertexHandle)) {\n if (realRingVertex == ringVertex) {\n found = true;\n }\n }\n if (!found) return false;\n }\n return true;\n };\n\n oneapi::tbb::parallel_for_each(vertices_sbegin(), vertices_end(),\n [&](const VertexHandle &vertex) {\n if (!data(vertex).isNew) {\n _mutex.lock();\n bar.update();\n _mutex.unlock();\n /* continue; */\n return;\n }\n\n // 在基面上找到公共顶点，并展开到2维平面计算重心坐标\n auto vertexFaceOption = baseLevelMesh->FindFace(point(vertex));\n if (!vertexFaceOption.has_value()) {\n _mutex.lock();\n bar.update();\n _mutex.unlock();\n /* continue; */\n return;\n }\n auto vertexFace = vertexFaceOption.value();\n\n for (const auto &face : originFaces) {\n std::array mapFace;\n const std::vector &fv = originFaceVertices[face];\n\n if (IsMapedInASingleFace(face)) { // 原面能够完全映射到基面上\n MapFaceFromOriginMesh(face, mapFace);\n if (IsInTriangle(point(vertex), mapFace)) {\n auto [alpha, beta, gamma] = CalculateBaryCoor(point(vertex), mapFace);\n Point newPoint =\n alpha * point(fv[0]) + beta * point(fv[1]) + gamma * point(fv[2]);\n point(vertex) = newPoint;\n break;\n }\n } else {\n\n std::vector baseFaces;\n std::vector fixVertex;\n for (const auto &vertexHandle : fv) {\n if (!IsVertexDeleted(vertexHandle)) {\n fixVertex.push_back(vertexHandle);\n continue;\n }\n\n auto baryCoor = data(vertexHandle).baryCoor.value();\n auto face = baseLevelMesh->FindFace(\n {baryCoor[0].first, baryCoor[1].first, baryCoor[2].first});\n\n if (face.has_value()) {\n baseFaces.push_back(face.value());\n }\n }\n\n VertexHandle commonVertex;\n if (baseFaces.size() == 3) {\n if (std::find(baseFaces.begin(), baseFaces.end(), vertexFace) ==\n baseFaces.end()) {\n continue;\n }\n commonVertex = findMaxCommonVertex(baseFaces);\n } else {\n bool foundCommonVertex = false;\n for (const auto &baseFace : baseFaces) {\n for (const auto &baseVert : baseLevelMesh->fv_range(baseFace)) {\n if (isRingFace(baseVert, vertexFace) &&\n isRingPoint(baseVert, fixVertex)) {\n commonVertex = baseVert;\n foundCommonVertex = true;\n break;\n }\n }\n if (foundCommonVertex) break;\n }\n if (!foundCommonVertex) continue;\n }\n\n Coordinate2DPair coorPair;\n baseLevelMesh->Calculate2D(commonVertex, coorPair);\n\n Coordinate2DMap coorMap(coorPair.begin(), coorPair.end());\n Point2D vertex2D(0, 0);\n auto vertex2DBaryCoor = baseLevelMesh->CalculateBaryCoor(point(vertex), vertexFace);\n for (const auto &vertex2DBaryCoorItem : vertex2DBaryCoor) {\n if (coorMap.find(vertex2DBaryCoorItem.first) == coorMap.end()) {\n continue;\n }\n vertex2D +=\n coorMap.at(vertex2DBaryCoorItem.first) * vertex2DBaryCoorItem.second;\n }\n\n std::array, 3> face2D;\n bool canMapTo2D = true;\n for (int i = 0; i < 3; i++) {\n face2D[i].first = fv[i];\n face2D[i].second = Point2D(0, 0);\n if (!IsVertexDeleted(fv[i])) {\n face2D[i].second = coorMap[fv[i]];\n continue;\n }\n\n auto baryCoor = data(fv[i]).baryCoor.value();\n for (const auto &baryCoorItem : baryCoor) {\n if (baryCoorItem.first == commonVertex) continue;\n if (coorMap.find(baryCoorItem.first) == coorMap.end()) {\n canMapTo2D = false;\n break;\n /* throw std::runtime_error(\"can't found item\"); */\n }\n face2D[i].second += coorMap.at(baryCoorItem.first) * baryCoorItem.second;\n }\n }\n if (!canMapTo2D) continue;\n\n std::array triangle{face2D[0].second, face2D[1].second,\n face2D[2].second};\n\n if (!IsInTriangle(vertex2D, triangle)) continue;\n\n auto [alpha, beta, gamma] = CalculateBaryCoor(vertex2D, triangle);\n\n point(vertex) = alpha * point(face2D[0].first) + beta * point(face2D[1].first) +\n gamma * point(face2D[2].first);\n break;\n }\n }\n _mutex.lock();\n bar.update();\n _mutex.unlock();\n });\n}\n\nstd::optional> MapMesh::UpdateParam(\n const std::vector> &faces,\n const std::map &point2DMap, const Point2D &point) {\n\n for (int i = 0; i < faces.size(); i++) {\n const auto &face = faces[i];\n std::array triangle;\n triangle[0] = point2DMap.at(face[0]);\n triangle[1] = point2DMap.at(face[1]);\n triangle[2] = point2DMap.at(face[2]);\n if (!IsInTriangle(point, triangle)) continue;\n\n auto [alpha, beta, gamma] = CalculateBaryCoor(point, triangle);\n return std::make_tuple(i, alpha, beta, gamma);\n }\n\n return std::nullopt;\n}\n\nvoid MapMesh::Calculate2D(VertexHandle vertex, Coordinate2DPair &coordinates) const {\n coordinates.clear();\n auto vertex3D = point(vertex);\n\n double K_i = 0;\n for (const auto &face : vf_range(vertex)) {\n K_i += CalculateAngle(vertex, face);\n }\n double a = 2 * M_PI / K_i;\n\n K_i = 0;\n\n VertexHandle lastVertex;\n int i = 0;\n for (const auto &ringPoint : vv_range(vertex)) {\n if (i != 0) {\n auto Vec1 = point(lastVertex) - point(vertex);\n auto Vec2 = point(ringPoint) - point(vertex);\n\n K_i += std::acos(Vec1.normalized().dot(Vec2.normalized()));\n }\n auto point3D = point(ringPoint);\n double r_k = (point3D - vertex3D).norm();\n\n Point2D point2D{std::pow(r_k, a) * std::cos(K_i * a), std::pow(r_k, a) * std::sin(K_i * a)};\n\n coordinates.emplace_back(ringPoint, point2D);\n lastVertex = ringPoint;\n\n i++;\n }\n}\n\n} // namespace Maps\n", "meta": {"hexsha": "cff6c6b539ce97723b22717ec5d4a86d5d8718a4", "size": 21795, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/MapsMesh.cc", "max_stars_repo_name": "45degree/MAPS", "max_stars_repo_head_hexsha": "aa2aacdda97ab67cc3e80aca3251000eed49d1e3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/MapsMesh.cc", "max_issues_repo_name": "45degree/MAPS", "max_issues_repo_head_hexsha": "aa2aacdda97ab67cc3e80aca3251000eed49d1e3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/MapsMesh.cc", "max_forks_repo_name": "45degree/MAPS", "max_forks_repo_head_hexsha": "aa2aacdda97ab67cc3e80aca3251000eed49d1e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2043189369, "max_line_length": 100, "alphanum_fraction": 0.5606331727, "num_tokens": 5684, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.588889130767832, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.299044887348973}} {"text": "// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n// ** Copyright UCAR, CSU (c) 1990 - 2018\n// ** University Corporation for Atmospheric Research (UCAR)\n// ** National Center for Atmospheric Research (NCAR)\n// ** Colorado State University\n// ** BSD licence applies\n// ** DISCLAIMER: THIS SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS\n// ** OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED\n// ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*\n\n#include \n#include \n#include \"Fractl.hh\"\n#include \"Params.hh\"\n#include \"Filters.hh\"\n#include \"Interps.hh\"\n\n// Eigen linear algebra library\n// http://eigen.tuxfamily.org/index.php?title=Main_Page\n#include \n\ndouble sumTimea = 0;\nint cntTimeb = 0;\ndouble sumTimeb = 0;\ndouble sumTimec = 0;\ndouble sumTimee = 0;\ndouble sumTimef = 0;\n\nbool Fractl::calcWinds()\n{\n // One approach is to iterate:\n // calculate V and U winds\n // calculate W winds\n // recalculate V and U winds using the new W winds\n // recalculate W with the new V, U.\n // etc.\n //\n // However, tests show that there is negligible gain\n // in accuracy after the first iteration.\n // So the loop limit is hardcoded at 1.\n\n for (int imain = 0; imain < 1; imain++) {\n // bool showStat = true;\n // Based on current w, calc u, v.\n if (gridType == Params::GRID_MISH)\n calcAllVUOnMish(\n\t\tnumNbrMax, // max num nearest nbrs\n\t\tpointVec, // all observations\n\t\tradarKdTree, // nearest nbr tree for pointVec\n\t\tcellMat);\n else\n calcAllVU(\n\t\tnumNbrMax, // max num nearest nbrs\n\t\tpointVec, // all observations\n\t\tradarKdTree, // nearest nbr tree for pointVec\n\t\tcellMat);\n\n \n printRunTime(\"calcAllVU\", &timea);\n\n // Run low-pass filtering if requested\n\n Filter *filter = FilterFactory::createFilter(uvFilter);\t\t// TOD indices\n if (filter != NULL) {\n filter->filter_U(cellMat, nradx, nrady, nradz, 1, NULL);\n filter->filter_V(cellMat, nradx, nrady, nradz, 1, NULL);\n delete filter;\n }\n\n // Run interpolation for missing data if requested\n // TODO: add old RadarWind interpolation and code Interp::interpolate\n\n Interp *interp = InterpFactory::createInterp(uvInterp);\n if (interp != NULL) {\n interp->interpolate_U(cellMat, nradx, nrady, nradz, std::numeric_limits::quiet_NaN());\n interp->interpolate_V(cellMat, nradx, nrady, nradz, std::numeric_limits::quiet_NaN());\n delete interp;\n }\n\n // NO LONGER USED:\n // Interpolate missing values from neighbors.\n //\n // The problem is that some cells don't have enough valid\n // neighbors to calculate their winds, so their values are\n // left as NaN.\n //\n // The idea was to fill the NaN cells\n // by interpolating the wind values from nearby cells.\n //\n // But what happens is that generally if a cell doesn't have\n // enough good neighbors for a valid wind calculation,\n // any neighbor cells we might use for interpolation are\n // pretty flakey.\n //xxx del interpolation?\n // Interpolate NaN values in cellMat.uu, cellMat.vv.\n //interpMissing( bugs, nradz, nrady, nradx, cellMat, tmpmat);\n //printRunTime(\"interpMissing for V,U\", &timea);\n\n // Based on u, v, calc w\n\n if (gridType == Params::GRID_MISH) \n calcAllWOnMish(cellMat);\n else\n calcAllW(cellMat);\n \n printRunTime(\"calcAllW\", &timea);\n\n // Run low-pass filtering on W if requested\n\n filter = FilterFactory::createFilter(wFilter);\n if (filter != NULL) {\n filter->filter_W(cellMat, nradx, nrady, nradz, 1, NULL); // TODO indices\n delete filter;\n }\n\n // Calc deltas using verification data, if any.\n // Write outTxt file.\n checkVerif(imain, cellMat);\n printRunTime(\"checkVerif\", &timea);\n } // for imain\n return true;\n}\n\n//======================================================================\n\n// Calculate V and U winds at all cells in the z,y,x grid.\n\nvoid Fractl::calcAllVU(\n\t\t long numNbrMax, // max num nearest nbrs\n\t\t vector *pointVec, // all observations\n\t\t KD_tree * radarKdTree, // nearest nbr tree for pointVec\n\t\t Cell ***& cellMat) // we set Cell.uu, vv\n{\n\n KD_real * centerLoc = new KD_real[ndim];\n long okCount = 0;\n\n for (long iz = 0; iz < nradz; iz++) {\n for (long iy = 0; iy < nrady; iy++) {\n for (long ix = 0; ix < nradx; ix++) {\n\n centerLoc[0] = zgridmin + iz * zgridinc;\n centerLoc[1] = ygridmin + iy * ygridinc;\n centerLoc[2] = xgridmin + ix * xgridinc;\n\n if (bugs >= Params::DEBUG_NORM) {\n cout << setprecision(5);\n cout << endl << \"calcAllVU: iz: \" << iz\n\t << \" iy: \" << iy\n\t << \" ix: \" << ix\n\t << \" z: \" << centerLoc[0]\n\t << \" y: \" << centerLoc[1]\n\t << \" x: \" << centerLoc[2]\n\t << endl;\n }\n\n Cell * pcell = & cellMat[iz][iy][ix];\n calcCellVU(\n\t\t centerLoc, // query point\n\t\t numNbrMax, // max num nearest nbrs\n\t\t pointVec, // all observations\n\t\t radarKdTree, // nearest nbr tree for pointVec\n\t\t pcell); // Cell.vv, uu are set.\n\n bool ok = false;\n if (isOkDouble( pcell->vv)\n\t && isOkDouble( pcell->uu))\n\t {\n\t ok = true;\n\t okCount++;\n\t }\n\n if (bugs >= Params::DEBUG_VERBOSE) {\n cout << setprecision(7);\n cout << \"calcAllVU: ok:\" << ok\n\t << \" iz: \" << iz\n\t << \" iy: \" << iy\n\t << \" ix: \" << ix\n\t << \" loc:\"\n\t << \" \" << centerLoc[0]\n\t << \" \" << centerLoc[1]\n\t << \" \" << centerLoc[2]\n\t << \" W: \" << cellMat[iz][iy][ix].ww\n\t << \" V: \" << cellMat[iz][iy][ix].vv\n\t << \" U: \" << cellMat[iz][iy][ix].uu << endl;\n }\n\n } // for ix\n } // for iy\n } // for iz\n\n cout << \"---------------- okCount: \" << okCount << endl;\n\n cout << \"sumTimea: \" << sumTimea << endl;\n cout << \"cntTimeb: \" << cntTimeb << \" sumTimeb: \" << sumTimeb << endl;\n cout << \"sumTimec: \" << sumTimec << endl;\n cout << \"sumTimee: \" << sumTimee << endl;\n cout << \"sumTimef: \" << sumTimef << endl;\n\n delete[] centerLoc;\n\n} // end calcAllVU\n\n//======================================================================\n\n// Try to calc V and U on the Samurai Mish grid\n\nvoid Fractl::calcAllVUOnMish(\n\t\t\t long numNbrMax, // max num nearest nbrs\n\t\t\t vector *pointVec, // all observations\n\t\t\t KD_tree * radarKdTree, // nearest nbr tree for pointVec\n\t\t\t Cell ***& cellMat) // we set Cell.uu, vv\n{\n\n KD_real * centerLoc = new KD_real[ndim];\n long okCount = 0;\n \n // for (long iz = 0; iz < nradz; iz++)\n // for (long iy = 0; iy < nrady; iy++)\n // for (long ix = 0; ix < nradx; ix++)\n\n // centerLoc[0] = zgridmin + iz * zgridinc;\n // centerLoc[1] = ygridmin + iy * ygridinc;\n // centerLoc[2] = xgridmin + ix * xgridinc;\n\n // This is the way Samurai iterates on the Mish.\n // *Pos is the position in meter of the observation\n // i* is the index of the position in node table\n \n for (int ii = -1; ii < (nradx); ii++) {\n for (int imu = -1; imu <= 1; imu += 2) {\n double iPos = xgridmin + xgridinc * (ii + (0.5 * sqrt(1. / 3.) * imu + 0.5));\n\t \n for (int ji = -1; ji < (nrady); ji++) {\n\tfor (int jmu = -1; jmu <= 1; jmu += 2) {\n\t double jPos = ygridmin + ygridinc * (ji + (0.5 * sqrt(1. / 3.) * jmu + 0.5));\n\t\t\n\t for (int ki = -1; ki < (nradz); ki++) {\n\t for (int kmu = -1; kmu <= 1; kmu += 2) {\n\t double kPos = zgridmin + zgridinc * (ki + (0.5 * sqrt(1. / 3.) * kmu + 0.5));\n\t\n\t int ix = (ii + 1) * 2 + (imu + 1) / 2;\n\t int iy = (ji + 1) * 2 + (jmu + 1) / 2;\n\t int iz = (ki + 1) * 2 + (kmu + 1) / 2;\n\n\t // centerLoc[0] = zgridmin + iz * zgridinc;\n\t // centerLoc[1] = ygridmin + iy * ygridinc;\n\t // centerLoc[2] = xgridmin + ix * xgridinc;\n\n\t centerLoc[0] = kPos;\n\t centerLoc[1] = jPos;\n\t centerLoc[2] = iPos;\n \n\t if (bugs >= Params::DEBUG_NORM) {\n\t\tstd::cout << setprecision(5);\n\t\tstd::cout << endl << \"calcAllVU: iz: \" << iz\n\t\t\t << \" iy: \" << iy\n\t\t\t << \" ix: \" << ix\n\t\t\t << \" z: \" << centerLoc[0]\n\t\t\t << \" y: \" << centerLoc[1]\n\t\t\t << \" x: \" << centerLoc[2]\n\t\t\t << endl;\n\t } \n\n\t Cell * pcell = & cellMat[iz][iy][ix];\n\t calcCellVU(centerLoc, // query point\n\t\t\t numNbrMax, // max num nearest nbrs\n\t\t\t pointVec, // all observations\n\t\t\t radarKdTree, // nearest nbr tree for pointVec\n\t\t\t pcell); // Cell.vv, uu are set.\n\n\t bool ok = false;\n\t if (isOkDouble( pcell->vv) && isOkDouble( pcell->uu)) {\n\t\tok = true;\n\t\tokCount++;\n\t }\n\n\t if (bugs >= Params::DEBUG_VERBOSE) {\n\t\tcout << setprecision(7);\n\t\tcout << \"calcAllVU: ok:\" << ok\n\t\t << \" iz: \" << iz\n\t\t << \" iy: \" << iy\n\t\t << \" ix: \" << ix\n\t\t << \" loc:\"\n\t\t << \" \" << centerLoc[0]\n\t\t << \" \" << centerLoc[1]\n\t\t << \" \" << centerLoc[2]\n\t\t << \" W: \" << cellMat[iz][iy][ix].ww\n\t\t << \" V: \" << cellMat[iz][iy][ix].vv\n\t\t << \" U: \" << cellMat[iz][iy][ix].uu << endl;\n\t }\n\t } \n\t } // ki\n\t}\n } // ji\n }\n } // ii\n\t\n cout << \"---------------- okCount: \" << okCount << endl;\n\n cout << \"sumTimea: \" << sumTimea << endl;\n cout << \"cntTimeb: \" << cntTimeb << \" sumTimeb: \" << sumTimeb << endl;\n cout << \"sumTimec: \" << sumTimec << endl;\n cout << \"sumTimee: \" << sumTimee << endl;\n cout << \"sumTimef: \" << sumTimef << endl;\n\n delete[] centerLoc;\n\n} // end calcAllVUOnMish\n\n\n//======================================================================\n\n// Calculate V and U winds for a single location.\n//\n// At a given location centerLoc, find the nearest nbrs\n// in pointVec, and use the radial velocities to calculate\n// the winds V, U, (not W).\n//\n// Let vx, vy, vz be estimates of the wind velocity,\n// and vr be the radial velocity.\n//\n// For each radar m, we use the linear model:\n// vr_est[m] = cos(theta) cos(elev) vx\n// + sin(theta) cos(elev) vy\n// + sin(elev) vz\n// vr_est[m] = conx vx + cony * vy + conz * vz\n//\n// Let E[m] = error = vr_true[m] - vr_est[m]\n//\n// We want to minimize Q = sum_m E[m]^2\n//\n//\n// Let\n// sumxx = sum(conx * conx)\n// sumxr = sum(conx * vr)\n// etc.\n//\n// Normal equations, derived from\n// 0 = d(Q)/d(vx), 0 = d(Q)/d(vy), 0 = d(Q)/d(vz),\n// give:\n// vx sumxx + vy sumxy + vz sumxz = sumxr\n// vx sumxy + vy sumyy + vz sumyz = sumyr\n// vx sumxz + vy sumyz + vz sumzz = sumzr\n//\n// Or for 2 dim,\n// vx sumxx + vy sumxy = sumxr - vz sumxz\n// vx sumxy + vy sumyy = sumyr - vz sumyz\n//\n// Using Cramer's rule on the 2-dim case:\n// Let demom = sumxx sumyy - sumxy^2\n// vx_hat = ( (sumxr - vz sumxz) sumyy - (sumyr - vz sumyz) sumxy ) / denom\n// vy_hat = ( (sumyr - vz sumyz) sumxx - (sumxr - vz sumxz) sumxy ) / denom\n\nvoid Fractl::calcCellVU(\n\t\t\tKD_real * centerLoc, // query point: z, y, x\n\t\t\tlong numNbrMax, // max num nearest nbrs\n\t\t\tvector *pointVec, // all observations\n\t\t\tKD_tree * radarKdTree, // nearest nbr tree for pointVec\n\t\t\tCell * pcell) // we fill vv, uu.\n{\n struct timeval timea;\n addDeltaTime( &timea, NULL);\n\n pcell->uu = numeric_limits::quiet_NaN();\n pcell->vv = numeric_limits::quiet_NaN();\n\n bool showDetail = testDetail(\n\t\t\t centerLoc[0], // z\n\t\t\t centerLoc[1], // y\n\t\t\t centerLoc[2]); // x\n\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n cout << setprecision(7);\n cout << \"calcCellVU.entry: showDetail:\" << endl;\n cout << \" centerLoc: z: \" << centerLoc[0] << endl;\n cout << \" centerLoc: y: \" << centerLoc[1] << endl;\n cout << \" centerLoc: x: \" << centerLoc[2] << endl;\n cout << \" ww: \" << pcell->ww << endl;\n cout << \" vv: \" << pcell->vv << endl;\n cout << \" uu: \" << pcell->uu << endl;\n cout << \" meanNbrDbz: \" << pcell->meanNbrDbz << endl;\n cout << \" meanNbrNcp: \" << pcell->meanNbrNcp << endl;\n cout << \" meanNbrElevDeg: \" << pcell->meanNbrElevDeg << endl;\n cout << \" meanNbrKeepDist: \" << pcell->meanNbrKeepDist << endl;\n cout << \" meanNbrOmitDist: \" << pcell->meanNbrOmitDist << endl;\n cout << \" condNum: \" << pcell->conditionNumber << endl;\n }\n\n if (numNbrMax == 0) throwerr(\"cell numNbrMax == 0\");\n\n int nbrIxs[numNbrMax];\n KD_real nbrDistSqs[numNbrMax]; // nbr dist^2\n for (long inbr = 0; inbr < numNbrMax; inbr++) {\n nbrIxs[inbr] = -1;\n }\n\n Statistic nbrDbzStat;\n Statistic nbrNcpStat;\n Statistic nbrElevDegStat;\n Statistic nbrKeepDistStat;\n Statistic nbrOmitDistStat;\n\n Point** nearPts = new Point *[numNbrMax];\n\n addDeltaTime( &timea, &sumTimea);\n struct timeval timeb;\n addDeltaTime( &timeb, NULL);\n\n // Find nearest nbrs\n radarKdTree->nnquery(\n\t\t centerLoc, // query point\n\t\t numNbrMax, // desired num nearest nbrs\n\t\t KD_EUCLIDEAN, // Metric\n\t\t 1, // MinkP\n\t\t nbrIxs, // out: parallel array, indices of nearest nbrs\n\t\t nbrDistSqs); // out: parallel array, squares of distances of nbrs\n\n cntTimeb++;\n addDeltaTime( &timeb, &sumTimeb);\n struct timeval timec;\n addDeltaTime( &timec, NULL);\n\n if (bugs >= Params::DEBUG_VERBOSE && showDetail) {\n cout << setprecision(7);\n cout << \" calcCellVU: showDetail: nearPts for centerLoc: z: \"\n\t << centerLoc[0] << \" y: \" << centerLoc[1]\n\t << \" x: \" << centerLoc[2] << endl;\n }\n\n int numNbrActual = 0;\n\n // Keep points within base + factor * aircraft dist\n\n for (long inbr = 0; inbr < numNbrMax; inbr++) {\n if (nbrIxs[inbr] < 0) throwerr(\"nbrIxs < 0\");\n\n Point * nearPt = pointVec->at( nbrIxs[inbr]);\n double aircraftDist = calcDistPtAircraft( nearPt);\n double localDist = calcDistLocPt( centerLoc, nearPt);\n double maxDist = maxDistBase + maxDistFactor * aircraftDist;\n\n // Use local distance constraint from grid point center\n double roi = sqrt(xgridinc * xgridinc + ygridinc * ygridinc + zgridinc * zgridinc);\n if (roi < maxDist) maxDist = roi;\n\n const char * msg;\n\n if (localDist < maxDist) {\n nbrDbzStat.addOb( nearPt->dbz);\n nbrNcpStat.addOb( nearPt->ncp);\n nbrElevDegStat.addOb( nearPt->elevRad * 180 / M_PI);\n nbrKeepDistStat.addOb( localDist);\n nearPts[numNbrActual++] = nearPt;\n msg = \"KEEP\";\n } // if localDist < maxDist\n\n else {\n nbrOmitDistStat.addOb( localDist);\n msg = \"OMIT\";\n }\n\n if (bugs >= Params::DEBUG_VERBOSE && showDetail) {\n cout << setprecision(5);\n cout << \" \" << msg\n\t << \" inbr: \" << inbr\n\t << \" dist: \" << localDist\n\t << \" pt:\"\n\t << \" coordz: \" << nearPt->coordz\n\t << \" coordy: \" << nearPt->coordy\n\t << \" coordx: \" << nearPt->coordx\n\t << \" vg: \" << nearPt->vg\n\t << endl;\n }\n\n } // for inbr\n\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n cout << \" calcCellVU: showDetail: cell z: \"\n\t << centerLoc[0] << \" y: \" << centerLoc[1]\n\t << \" x: \" << centerLoc[2] << \" numNbrActual: \" << numNbrActual << endl;\n }\n\n if (numNbrActual >= 2) { // if numNbrActual is ok\n\n pcell->meanNbrDbz = nbrDbzStat.dsum / nbrDbzStat.numGood;\n pcell->meanNbrNcp = nbrNcpStat.dsum / nbrNcpStat.numGood;\n pcell->meanNbrElevDeg = nbrElevDegStat.dsum / nbrElevDegStat.numGood;\n pcell->meanNbrKeepDist = nbrKeepDistStat.dsum / nbrKeepDistStat.numGood;\n pcell->meanNbrOmitDist = nbrOmitDistStat.dsum / nbrOmitDistStat.numGood;\n\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n for (long inbr = 0; inbr < numNbrActual; inbr++) {\n\tPoint * pt = nearPts[inbr];\n\tcout << setprecision(7);\n\tcout << \" calcCellVU: showDetail: nbr: inbr: \" << inbr\n\t << \" vg: \" << pt->vg\n\t << \" dbz: \" << pt->dbz\n\t << \" ncp: \" << pt->ncp\n\t << \" theta deg: \" << (pt->thetaRad * 180 / M_PI)\n\t << \" elev deg: \" << (pt->elevRad * 180 / M_PI)\n\t << setprecision(15)\n\t << \" deltaTime: \"\n\t << (pt->rayTime - nearPts[0]->rayTime)\n\t << endl;\n }\n for (long inbr = 0; inbr < numNbrActual; inbr++) {\n\tPoint * pt = nearPts[inbr];\n\tcout << \" showDetail.from.aircraft.to.nbr: set arrow \"\n\t << (inbr + 1)\n\t << \" from \" << pt->aircraftx << \",\" << pt->aircrafty\n\t << \" to \" << pt->coordx << \",\" << pt->coordy\n\t << endl;\n }\n } // if showDetail\n\n addDeltaTime( &timec, &sumTimec);\n struct timeval timee;\n addDeltaTime( &timee, NULL);\n\n\n // 3d solve\n // vr = cos(theta) cos(elev) vx\n // + sin(theta) cos(elev) vy\n // + sin(elev) vz\n\n // 2d solve\n // vr - sin(elev) vz = cos(theta) cos(elev) vx\n // + sin(theta) cos(elev) vy\n\n\n // Find wwind = W wind estimate near the pt.\n double wwind = pcell->ww;\n bool isCellOk = false;\n\n if (useEigen) {\n\n Eigen::MatrixXd amat( numNbrActual, 2);\n Eigen::VectorXd bvec( numNbrActual);\n\n for (long inbr = 0; inbr < numNbrActual; inbr++) {\n\tPoint * pt = nearPts[inbr];\n\tamat( inbr, 0) = cos( pt->thetaRad) * cos( pt->elevRad);\n\tamat( inbr, 1) = sin( pt->thetaRad) * cos( pt->elevRad);\n\n\t// Find wwind = W wind estimate near the pt.\n\tdouble wwind = pcell->ww;\n\n\tbvec( inbr) = pt->vg - wwind * sin( pt->elevRad);\n }\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n\tcout << \"\\n calcCellVU: eigen: amat:\\n\" << amat << endl;\n\tcout << \"\\n calcCellVU: eigen: bvec:\\n\" << bvec << endl;\n }\n\n Eigen::JacobiSVD svd(\n\t\t\t\t\t amat, Eigen::ComputeThinU | Eigen::ComputeThinV);\n Eigen::VectorXd singVals = svd.singularValues();\n Eigen::MatrixXd thinV = svd.matrixV();\n long slen = singVals.size();\n // long vlen = thinV.rows();\n\n pcell->conditionNumber = numeric_limits::infinity();\n if (slen > 0 && singVals[slen-1] != 0)\n\tpcell->conditionNumber = singVals[0] / singVals[slen-1];\n\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n\tcout << \"\\n calcCellVU: eigen: singVals:\\n\" << singVals << endl;\n\tcout << \"\\n calcCellVU: num nonzeroSingularValues:\\n\"\n\t << svd.nonzeroSingularValues() << endl;\n\tcout << \" calcCellVU: conditionNumber: \"\n\t << pcell->conditionNumber << endl;\n }\n\n // Using a conditionNumberCutoff > 10 causes some cells\n // to have extreme values for U and V.\n\n if (pcell->conditionNumber < conditionNumberCutoff)\n\tisCellOk = true;\n if (isCellOk) {\n\tEigen::VectorXd xvec = svd.solve( bvec);\n\tEigen::VectorXd errvec = amat * xvec - bvec;\n\t// double maxAbsErr = errvec.array().abs().maxCoeff();\n\t// double meanSqErr = errvec.dot( errvec) / numNbrActual; // dot product\n\n\tpcell->vv = xvec(1); // v\n\tpcell->uu = xvec(0); // u\n\n\tdouble ustd = 0;\n\tdouble vstd = 0;\n\n\tfor (long s = 0; s < slen; s++) {\n\t // double thin0 = TODO check if the calls to thinV() has side effects\n\t thinV(0, s);\n\t // double thin1 =\n\t thinV(1, s);\n\t // double sing =\n\t singVals[s];\n\t ustd += pow( (thinV(s, 0) / singVals[s]) , 2.0);\n\t vstd += pow( (thinV(s, 1) / singVals[s]) , 2.0);\n\t}\n\tpcell->ustd = sqrt(ustd);\n\tpcell->vstd = sqrt(vstd);\n\n if (fabs(pcell->vv) > maxV) {\n pcell->vv = numeric_limits::quiet_NaN();\n\t pcell->vstd = numeric_limits::quiet_NaN();\n\t}\n if (fabs(pcell->uu) > maxU) {\n pcell->uu = numeric_limits::quiet_NaN();\n\t pcell->ustd = numeric_limits::quiet_NaN();\n\t}\n\n } // if isCellOk\n } // if useEigen\n\n\n // Else use cramer's method\n else {\n double sxx = 0;\n double sxy = 0;\n double syy = 0;\n double sxz = 0;\n double syz = 0;\n\n for (long inbr = 0; inbr < numNbrActual; inbr++) {\n\tPoint * pt = nearPts[inbr];\n\tdouble xval = cos( pt->thetaRad) * cos( pt->elevRad);\n\tdouble yval = sin( pt->thetaRad) * cos( pt->elevRad);\n\tdouble zval = pt->vg - wwind * sin( pt->elevRad);\n\n\tsxx += xval * xval;\n\tsxy += xval * yval;\n\tsyy += yval * yval;\n\tsxz += xval * zval;\n\tsyz += yval * zval;\n }\n double detbase = sxx*syy - sxy*sxy;\n double det1 = sxz*syy - syz*sxy;\n double det2 = sxx*syz - sxy*sxz;\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n\tcout << \" calcCellVU: cramer: showDetail: \"\n\t << \" sxx: \" << sxx\n\t << \" sxy: \" << sxy\n\t << \" syy: \" << syy\n\t << \" sxz: \" << sxz\n\t << \" syz: \" << syz << endl;\n\tcout << \" calcCellVU: cramer: showDetail: \"\n\t << \" detbase: \" << detbase\n\t << \" det1: \" << det1\n\t << \" det2: \" << det2 << endl;\n }\n\n // Using a detCutoff <= 0.01 causes some cells\n // to have extreme values for U and V.\n // A detCutoff of 0.1 gives roughly similar results to using\n // a conditionNumber cutoff of 10.\n double detCutoff = 0.1; // xxxxxxxxx\n\n if (fabs(detbase) > detCutoff) {\n\tpcell->uu = det1 / detbase;\n\tpcell->vv = det2 / detbase;\n }\n }\n\n addDeltaTime( &timee, &sumTimee);\n delete[] nearPts;\n } // else numNbrActual is ok\n\n struct timeval timef;\n addDeltaTime( &timef, NULL);\n\n if (bugs >= Params::DEBUG_EXTRA && showDetail) {\n cout << setprecision(7);\n cout << \"calcCellVU.exit: showDetail:\" << endl;\n cout << \" centerLoc: z: \" << centerLoc[0] << endl;\n cout << \" centerLoc: y: \" << centerLoc[1] << endl;\n cout << \" centerLoc: x: \" << centerLoc[2] << endl;\n cout << \" ww: \" << pcell->ww << endl;\n cout << \" vv: \" << pcell->vv << endl;\n cout << \" uu: \" << pcell->uu << endl;\n cout << \" meanNbrDbz: \" << pcell->meanNbrDbz << endl;\n cout << \" meanNbrNcp: \" << pcell->meanNbrNcp << endl;\n cout << \" meanNbrElevDeg: \" << pcell->meanNbrElevDeg << endl;\n cout << \" meanNbrKeepDist: \" << pcell->meanNbrKeepDist << endl;\n cout << \" meanNbrOmitDist: \" << pcell->meanNbrOmitDist << endl;\n cout << \" condNum: \" << pcell->conditionNumber << endl;\n }\n\n} // end calcCellVU\n\n// xxx all alloc: delete\n\n//======================================================================\n\n\n// Calculate the W (vertical) winds for all cells in the z,y,x grid.\n//\n// Consider the vertical column of cells for some\n// given horizontal coordinates iy, ix.\n// By the mass continuity equation, the total volume of air coming\n// into the column must equal the total volume of air leaving the column.\n//\n// 0 = totalFlow = sum_iz (density_iz * sideFlow_iz) + endFlow\n// where\n// density_iz = the density at level iz\n// sideFlow_iz = flow through the sides of the cell at level iz\n// endFlow = flow in the bottom and out the top end of the column\n// = densityBot * bottomFlow - densityTop * topFlow\n//\n// We assume the end flows are 0, so\n// bottendFlow = 0\n// topFlow = 0\n// endFlow = 0\n//\n// sideFlow_iz = uFlow_iz + vFlow_iz\n// uFlow_iz = (flow in from cell ix-1) - (flow out to cell ix+1)\n// uFlow_iz = 0.5 * (u[ix-1] + u[ix]) - 0.5 * (u[ix] + u[ix+1])\n// = 0.5 * (u[ix-1] - u[ix+1])\n//\n// sideFlow_iz = 0.5 * (u[ix-1] - u[ix+1] + v[ix-1] - v[ix+1])\n//\n// 0 = totalFlow = sum_iz (density_iz * 0.5 * (\n// v[iy-1] - v[iy+1]\n// + u[ix-1] - u[ix+1]))\n//\n// But in real life the totalFlow sum is not 0.\n//\n// Now we ask what modifications to the U and V values\n// would make the totalFlow 0.\n// We want to modify those U,V values with larger elevation angles more.\n// xxx future: handle geometric uncertainty values too.\n//\n// At each layer, we have 4 terms to adjust: 2 U terms and 2 V terms.\n// Let us subtract h[iz] from each term on level iz.\n//\n// Find h[iz] such that:\n// 0 = sum_iz (density_iz * 0.5 * (\n// (v[iy-1]-h[iz]) - (v[iy+1]+h[iz])\n// + (u[ix-1]-h[iz]) - (u[ix+1])+h[iz]))\n//\n// = totalFlow - sum_iz (density_iz * 0.5 * 4 * h[iz])\n//\n// totalFlow = 2 * sum_iz (density_iz * h[iz])\n//\n// Let h[iz] be weighted by the elevation angle, so\n// h[iz] = H * wgt[iz]\n// wgt[iz] = cos(elevationAngle)\n//\n// totalFlow = 2 * sum_iz (density[iz] * H * wgt[iz])\n// H = totalFlow / (2 * sum_iz (density[iz] * wgt[iz]))\n\nvoid Fractl::calcAllWOnMish(\n\t\t Cell ***& cellMat) // We set Cell.ww\n{\n long maxx = (xgridmax - xgridmin) * 2 / xgridinc + 1;\n long maxy = (ygridmax - ygridmin) * 2 / ygridinc + 1; \n long maxz = (zgridmax - zgridmin) * 2 / zgridinc + 1;\n \n double * density = new double[maxz + 3];\t // range is 0..maxz\n double * wgts = new double[maxz + 3];\n \n // double * density = new double[nradz];\n // double * wgts = new double[nradz];\n \n // for (long iz = 0; iz < nradz; iz++)\n // density[iz] = calcDensity( zgridmin + iz * zgridinc);\n\n // Use samurai index computation since we need both position and index\n \n for (int ki = -1; ki < (nradz); ki++) {\n for (int kmu = -1; kmu <= 1; kmu += 2) {\n double kPos = zgridmin + zgridinc * (ki + (0.5 * sqrt(1. / 3.) * kmu + 0.5));\n int ik = (ki + 1) * 2 + (kmu + 1) / 2;\n density[ik] = calcDensity(kPos);\n }\n }\n\n // Omit the edges of the region as we use ix-1, ix+1, iy-1, iy+1.\n \n // for (long iy = 1; iy < nrady - 1; iy++)\n // for (long ix = 1; ix < nradx - 1; ix++)\n\n for (long iy = 1; iy < maxy - 1; iy++) {\n for (long ix = 1; ix < maxx - 1; ix++) {\n\n // for (long iz = 0; iz < nradz; iz++)\n for (long iz = 0; iz < maxz; iz++) {\n // xxx Future:\n // Find c = the nearest cell to this one\n // through which the aircraft flew.\n // Let cosElev = horizDistToC / slantDistToC\n // wgt = cosElev\n\n wgts[iz] = 1.0;\n }\n\n // Calc totalFlow = sum of everything flowing into the column,\n // not counting the top or bottom faces.\n\n double totalFlow = 0;\n double sumWgt = 0;\n\n // for (long iz = 0; iz < nradz; iz++)\n for (long iz = 0; iz < maxz; iz++) {\n\t\n if ( isOkDouble( cellMat[iz][iy][ix-1].uu)\n\t && isOkDouble( cellMat[iz][iy][ix+1].uu)\n\t && isOkDouble( cellMat[iz][iy-1][ix].vv)\n\t && isOkDouble( cellMat[iz][iy+1][ix].vv))\n\t {\n\t totalFlow += density[iz] * 0.5\n\t * ( cellMat[iz][iy][ix-1].uu - cellMat[iz][iy][ix+1].uu\n\t\t + cellMat[iz][iy-1][ix].vv - cellMat[iz][iy+1][ix].vv);\n\t sumWgt += density[iz] * wgts[iz];\n\t }\n } // for iz\n\n double hcon;\n if (fabs(sumWgt) < epsilon) hcon = 0;\n else hcon = totalFlow / (2 * sumWgt);\n\n // Calc W wind = totalFlow, starting at the bottom,\n // using the modified U, V winds.\n double wwind = baseW;\n // for (long iz = 0; iz < nradz; iz++)\n for (long iz = 0; iz < maxz; iz++) {\n if ( isOkDouble( cellMat[iz][iy][ix-1].uu)\n\t && isOkDouble( cellMat[iz][iy][ix+1].uu)\n\t && isOkDouble( cellMat[iz][iy-1][ix].vv)\n\t && isOkDouble( cellMat[iz][iy+1][ix].vv))\n\t {\n\t wwind += density[iz] * 0.5\n\t * ( cellMat[iz][iy][ix-1].uu - cellMat[iz][iy][ix+1].uu\n\t\t + cellMat[iz][iy-1][ix].vv - cellMat[iz][iy+1][ix].vv\n\t\t - 4 * hcon * wgts[iz]);\n\t if (! isOkDouble( wwind))\n\t throwerr(\"calcAllW: invalid w wind\");\n\t if (fabs(wwind) < maxW) {\n\t cellMat[iz][iy][ix].ww = wwind;\n\t } else cellMat[iz][iy][ix].ww = numeric_limits::quiet_NaN();\n\t } else cellMat[iz][iy][ix].ww = numeric_limits::quiet_NaN();\n } // for iz\n if (fabs(wwind - baseW) > epsilon) {\n cout << setprecision(15);\n cout << \"calcAllW: iy: \" << iy << \" ix: \" << ix\n\t << \" baseW: \" << baseW << \" wwind: \" << wwind << endl;\n cout.flush();\n throwerr(\"wwind error\");\n }\n } // for ix\n } // for iy\n\n //xxx maybe omit:\n // We only calculated the inner points for iy, ix.\n // But we also will need the edge values when\n // we calc the next iteration of U, V values.\n // So set the edges from the nearest interior points.\n // May be NaN.\n\n // for (long iz = 0; iz < nradz; iz++)\n for (long iz = 0; iz < maxz; iz++) {\n // Corners\n cellMat[iz][0][0].ww = cellMat[iz][1][1].ww;\n cellMat[iz][0][maxx-1].ww = cellMat[iz][1][maxx-2].ww;\n cellMat[iz][maxy-1][0].ww = cellMat[iz][maxy-2][1].ww;\n cellMat[iz][maxy-1][maxx-1].ww = cellMat[iz][maxy-2][maxx-2].ww;\n\n // Side edges\n // for (long iy = 1; iy < nrady - 1; iy++)\n for (long iy = 1; iy < maxy - 1; iy++) { \n cellMat[iz][iy][0].ww = cellMat[iz][iy][1].ww;\n cellMat[iz][iy][maxx-1].ww = cellMat[iz][iy][maxx-2].ww;\n }\n // Top and bottom edges\n // for (long ix = 1; ix < nradx - 1; ix++)\n for (long ix = 1; ix < maxx - 1; ix++) {\n cellMat[iz][0][ix].ww = cellMat[iz][1][ix].ww;\n cellMat[iz][maxy-1][ix].ww = cellMat[iz][maxy-2][ix].ww;\n }\n } // for iz\n\n delete[] density;\n delete[] wgts;\n\n} // end calcAllWOnMish\n\n//==================================================================\n\nvoid Fractl::calcAllW(\n\t\t Cell ***& cellMat) // We set Cell.ww\n{\n double * density = new double[nradz];\n double * wgts = new double[nradz];\n for (long iz = 0; iz < nradz; iz++)\n density[iz] = calcDensity( zgridmin + iz * zgridinc);\n\n // Omit the edges of the region as we use ix-1, ix+1, iy-1, iy+1.\n for (long iy = 1; iy < nrady - 1; iy++) {\n for (long ix = 1; ix < nradx - 1; ix++) {\n\n for (long iz = 0; iz < nradz; iz++) {\n // xxx Future:\n // Find c = the nearest cell to this one\n // through which the aircraft flew.\n // Let cosElev = horizDistToC / slantDistToC\n // wgt = cosElev\n\n wgts[iz] = 1.0;\n }\n\n // Calc totalFlow = sum of everything flowing into the column,\n // not counting the top or bottom faces.\n\n double totalFlow = 0;\n double sumWgt = 0;\n\n for (long iz = 0; iz < nradz; iz++) {\n if ( isOkDouble( cellMat[iz][iy][ix-1].uu)\n\t && isOkDouble( cellMat[iz][iy][ix+1].uu)\n\t && isOkDouble( cellMat[iz][iy-1][ix].vv)\n\t && isOkDouble( cellMat[iz][iy+1][ix].vv))\n\t {\n\t totalFlow += density[iz] * 0.5\n\t * ( cellMat[iz][iy][ix-1].uu - cellMat[iz][iy][ix+1].uu\n\t\t + cellMat[iz][iy-1][ix].vv - cellMat[iz][iy+1][ix].vv);\n\t sumWgt += density[iz] * wgts[iz];\n\n\t bool showDetail = testDetail(\n\t\t\t\t\t zgridmin + iz * zgridinc, // z\n\t\t\t\t\t ygridmin + iy * ygridinc, // y\n\t\t\t\t\t xgridmin + ix * xgridinc); // x\n\t // detailSpec); // z, y, x, delta\n\n\t if (showDetail) {\n\t cout << setprecision(7);\n\t cout << \"calcAllW: showDetail:\" << endl\n\t\t << \" iz: \" << iz << endl\n\t\t << \" iy: \" << iy << endl\n\t\t << \" ix: \" << ix << endl\n\t\t << \" den: \" << density[iz] << endl\n\t\t << \" wgt: \" << wgts[iz] << endl\n\t\t << \" U-: \" << cellMat[iz][iy][ix-1].uu << endl\n\t\t << \" U+: \" << cellMat[iz][iy][ix+1].uu << endl\n\t\t << \" V-: \" << cellMat[iz][iy-1][ix].vv << endl\n\t\t << \" V+: \" << cellMat[iz][iy+1][ix].vv << endl;\n\t }\n\t }\n } // for iz\n\n double hcon;\n if (fabs(sumWgt) < epsilon) hcon = 0;\n else hcon = totalFlow / (2 * sumWgt);\n\n // Calc W wind = totalFlow, starting at the bottom,\n // using the modified U, V winds.\n double wwind = baseW;\n for (long iz = 0; iz < nradz; iz++) {\n if ( isOkDouble( cellMat[iz][iy][ix-1].uu)\n\t && isOkDouble( cellMat[iz][iy][ix+1].uu)\n\t && isOkDouble( cellMat[iz][iy-1][ix].vv)\n\t && isOkDouble( cellMat[iz][iy+1][ix].vv))\n\t {\n\t wwind += density[iz] * 0.5\n\t * ( cellMat[iz][iy][ix-1].uu - cellMat[iz][iy][ix+1].uu\n\t\t + cellMat[iz][iy-1][ix].vv - cellMat[iz][iy+1][ix].vv\n\t\t - 4 * hcon * wgts[iz]);\n\t if (! isOkDouble( wwind))\n\t throwerr(\"calcAllW: invalid w wind\");\n if (fabs(wwind) < maxW) {\n cellMat[iz][iy][ix].ww = wwind;\n } else cellMat[iz][iy][ix].ww = numeric_limits::quiet_NaN();\n\n\t bool showDetail = testDetail(\n\t\t\t\t\t zgridmin + iz * zgridinc, // z\n\t\t\t\t\t ygridmin + iy * ygridinc, // y\n\t\t\t\t\t xgridmin + ix * xgridinc); // x\n\n\t if (showDetail) {\n\t cout << setprecision(7);\n\t cout << \"calcAllW: showDetail:\" << endl\n\t\t << \" iz: \" << iz << endl\n\t\t << \" iy: \" << iy << endl\n\t\t << \" ix: \" << ix << endl\n\t\t << \" den: \" << density[iz] << endl\n\t\t << \" U-: \" << cellMat[iz][iy][ix-1].uu << endl\n\t\t << \" U+: \" << cellMat[iz][iy][ix+1].uu << endl\n\t\t << \" V-: \" << cellMat[iz][iy-1][ix].vv << endl\n\t\t << \" V+: \" << cellMat[iz][iy+1][ix].vv << endl\n\t\t << \" hcon: \" << hcon << endl\n\t\t << \" wgt: \" << wgts[iz] << endl\n\t\t << \" con: \" << (4 * hcon * wgts[iz]) << endl\n\t\t << \" wwind: \" << wwind << endl;\n\t }\n\t }\n else cellMat[iz][iy][ix].ww = numeric_limits::quiet_NaN();\n } // for iz\n if (fabs(wwind - baseW) > epsilon) {\n cout << setprecision(15);\n cout << \"calcAllW: iy: \" << iy << \" ix: \" << ix\n\t << \" baseW: \" << baseW << \" wwind: \" << wwind << endl;\n cout.flush();\n throwerr(\"wwind error\");\n }\n } // for ix\n } // for iy\n\n\n //xxx maybe omit:\n // We only calculated the inner points for iy, ix.\n // But we also will need the edge values when\n // we calc the next iteration of U, V values.\n // So set the edges from the nearest interior points.\n // May be NaN.\n\n for (long iz = 0; iz < nradz; iz++) {\n // Corners\n cellMat[iz][0][0].ww = cellMat[iz][1][1].ww;\n cellMat[iz][0][nradx-1].ww = cellMat[iz][1][nradx-2].ww;\n cellMat[iz][nrady-1][0].ww = cellMat[iz][nrady-2][1].ww;\n cellMat[iz][nrady-1][nradx-1].ww = cellMat[iz][nrady-2][nradx-2].ww;\n\n // Side edges\n for (long iy = 1; iy < nrady - 1; iy++) {\n cellMat[iz][iy][0].ww = cellMat[iz][iy][1].ww;\n cellMat[iz][iy][nradx-1].ww = cellMat[iz][iy][nradx-2].ww;\n }\n // Top and bottom edges\n for (long ix = 1; ix < nradx - 1; ix++) {\n cellMat[iz][0][ix].ww = cellMat[iz][1][ix].ww;\n cellMat[iz][nrady-1][ix].ww = cellMat[iz][nrady-2][ix].ww;\n }\n } // for iz\n\n delete[] density;\n delete[] wgts;\n\n} // end calcAllWOnMish\n\n//==================================================================\n\n// Calc distance from between a Point and the aircraft\n\ndouble Fractl::calcDistPtAircraft( Point * pta) {\n double sumsq = 0;\n double delta;\n delta = pta->coordz - pta->aircraftz;\n sumsq += delta * delta;\n delta = pta->coordy - pta->aircrafty;\n sumsq += delta * delta;\n delta = pta->coordx - pta->aircraftx;\n sumsq += delta * delta;\n return sqrt( sumsq);\n}\n\n//==================================================================\n\n// Calc distance from a location to Point, in km.\n\ndouble Fractl::calcDistLocPt( double * loc, Point * pta) {\n double sumsq = 0;\n double delta;\n delta = loc[0] - pta->coordz;\n sumsq += delta * delta;\n delta = loc[1] - pta->coordy;\n sumsq += delta * delta;\n delta = loc[2] - pta->coordx;\n sumsq += delta * delta;\n return sqrt( sumsq);\n}\n\n//==================================================================\n\n// Calc distance between two Points, in km.\n\ndouble Fractl::calcDistPtPt( Point * pta, Point * ptb) {\n double sumsq = 0;\n double delta;\n delta = pta->coordz - ptb->coordz;\n sumsq += delta * delta;\n delta = pta->coordy - ptb->coordy;\n sumsq += delta * delta;\n delta = pta->coordx - ptb->coordx;\n sumsq += delta * delta;\n return sqrt( sumsq);\n}\n", "meta": {"hexsha": "b6fa54620955d676a1c9a87ee20806a2846e3e0c", "size": 35308, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/calcWinds.cc", "max_stars_repo_name": "nsf-lrose/FRACTL", "max_stars_repo_head_hexsha": "4c4dd6840fbc3319947f60e337484367dc22d252", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2022-03-17T03:29:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T03:30:07.000Z", "max_issues_repo_path": "src/calcWinds.cc", "max_issues_repo_name": "wujk1122/fractl", "max_issues_repo_head_hexsha": "4c4dd6840fbc3319947f60e337484367dc22d252", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/calcWinds.cc", "max_forks_repo_name": "wujk1122/fractl", "max_forks_repo_head_hexsha": "4c4dd6840fbc3319947f60e337484367dc22d252", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-01-28T05:46:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-28T05:46:49.000Z", "avg_line_length": 32.4522058824, "max_line_length": 100, "alphanum_fraction": 0.5369038178, "num_tokens": 11813, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.665410558746814, "lm_q2_score": 0.44939263446475963, "lm_q1q2_score": 0.2990306039958984}} {"text": "/**\r\n * \\file Math.hpp\r\n * \\brief Header for GeographicLib::Math class\r\n *\r\n * Copyright (c) Charles Karney (2008-2019) and licensed\r\n * under the MIT/X11 License. For more information, see\r\n * https://geographiclib.sourceforge.io/\r\n **********************************************************************/\r\n\r\n// Constants.hpp includes Math.hpp. Place this include outside Math.hpp's\r\n// include guard to enforce this ordering.\r\n#include \r\n\r\n#if !defined(GEOGRAPHICLIB_MATH_HPP)\r\n#define GEOGRAPHICLIB_MATH_HPP 1\r\n\r\n/**\r\n * Are C++11 math functions available?\r\n **********************************************************************/\r\n#if !defined(GEOGRAPHICLIB_CXX11_MATH)\r\n// Recent versions of g++ -std=c++11 (4.7 and later?) set __cplusplus to 201103\r\n// and support the new C++11 mathematical functions, std::atanh, etc. However\r\n// the Android toolchain, which uses g++ -std=c++11 (4.8 as of 2014-03-11,\r\n// according to Pullan Lu), does not support std::atanh. Android toolchains\r\n// might define __ANDROID__ or ANDROID; so need to check both. With OSX the\r\n// version is GNUC version 4.2 and __cplusplus is set to 201103, so remove the\r\n// version check on GNUC.\r\n# if defined(__GNUC__) && __cplusplus >= 201103 && \\\r\n !(defined(__ANDROID__) || defined(ANDROID) || defined(__CYGWIN__))\r\n# define GEOGRAPHICLIB_CXX11_MATH 1\r\n// Visual C++ 12 supports these functions\r\n# elif defined(_MSC_VER) && _MSC_VER >= 1800\r\n# define GEOGRAPHICLIB_CXX11_MATH 1\r\n# else\r\n# define GEOGRAPHICLIB_CXX11_MATH 0\r\n# endif\r\n#endif\r\n\r\n#if !defined(GEOGRAPHICLIB_WORDS_BIGENDIAN)\r\n# define GEOGRAPHICLIB_WORDS_BIGENDIAN 0\r\n#endif\r\n\r\n#if !defined(GEOGRAPHICLIB_HAVE_LONG_DOUBLE)\r\n# define GEOGRAPHICLIB_HAVE_LONG_DOUBLE 0\r\n#endif\r\n\r\n#if !defined(GEOGRAPHICLIB_PRECISION)\r\n/**\r\n * The precision of floating point numbers used in %GeographicLib. 1 means\r\n * float (single precision); 2 (the default) means double; 3 means long double;\r\n * 4 is reserved for quadruple precision. Nearly all the testing has been\r\n * carried out with doubles and that's the recommended configuration. In order\r\n * for long double to be used, GEOGRAPHICLIB_HAVE_LONG_DOUBLE needs to be\r\n * defined. Note that with Microsoft Visual Studio, long double is the same as\r\n * double.\r\n **********************************************************************/\r\n# define GEOGRAPHICLIB_PRECISION 2\r\n#endif\r\n\r\n#include \r\n#include \r\n#include \r\n\r\n#if GEOGRAPHICLIB_PRECISION == 4\r\n#include \r\n#include \r\n#include \r\n#elif GEOGRAPHICLIB_PRECISION == 5\r\n#include \r\n#endif\r\n\r\n#if GEOGRAPHICLIB_PRECISION > 3\r\n// volatile keyword makes no sense for multiprec types\r\n#define GEOGRAPHICLIB_VOLATILE\r\n// Signal a convergence failure with multiprec types by throwing an exception\r\n// at loop exit.\r\n#define GEOGRAPHICLIB_PANIC \\\r\n (throw GeographicLib::GeographicErr(\"Convergence failure\"), false)\r\n#else\r\n#define GEOGRAPHICLIB_VOLATILE volatile\r\n// Ignore convergence failures with standard floating points types by allowing\r\n// loop to exit cleanly.\r\n#define GEOGRAPHICLIB_PANIC false\r\n#endif\r\n\r\nnamespace GeographicLib {\r\n\r\n /**\r\n * \\brief Mathematical functions needed by %GeographicLib\r\n *\r\n * Define mathematical functions in order to localize system dependencies and\r\n * to provide generic versions of the functions. In addition define a real\r\n * type to be used by %GeographicLib.\r\n *\r\n * Example of use:\r\n * \\include example-Math.cpp\r\n **********************************************************************/\r\n class GEOGRAPHICLIB_EXPORT Math {\r\n private:\r\n void dummy(); // Static check for GEOGRAPHICLIB_PRECISION\r\n Math(); // Disable constructor\r\n public:\r\n\r\n#if GEOGRAPHICLIB_HAVE_LONG_DOUBLE\r\n /**\r\n * The extended precision type for real numbers, used for some testing.\r\n * This is long double on computers with this type; otherwise it is double.\r\n **********************************************************************/\r\n typedef long double extended;\r\n#else\r\n typedef double extended;\r\n#endif\r\n\r\n#if GEOGRAPHICLIB_PRECISION == 2\r\n /**\r\n * The real type for %GeographicLib. Nearly all the testing has been done\r\n * with \\e real = double. However, the algorithms should also work with\r\n * float and long double (where available). (CAUTION: reasonable\r\n * accuracy typically cannot be obtained using floats.)\r\n **********************************************************************/\r\n typedef double real;\r\n#elif GEOGRAPHICLIB_PRECISION == 1\r\n typedef float real;\r\n#elif GEOGRAPHICLIB_PRECISION == 3\r\n typedef extended real;\r\n#elif GEOGRAPHICLIB_PRECISION == 4\r\n typedef boost::multiprecision::float128 real;\r\n#elif GEOGRAPHICLIB_PRECISION == 5\r\n typedef mpfr::mpreal real;\r\n#else\r\n typedef double real;\r\n#endif\r\n\r\n /**\r\n * @return the number of bits of precision in a real number.\r\n **********************************************************************/\r\n static int digits();\r\n\r\n /**\r\n * Set the binary precision of a real number.\r\n *\r\n * @param[in] ndigits the number of bits of precision.\r\n * @return the resulting number of bits of precision.\r\n *\r\n * This only has an effect when GEOGRAPHICLIB_PRECISION = 5. See also\r\n * Utility::set_digits for caveats about when this routine should be\r\n * called.\r\n **********************************************************************/\r\n static int set_digits(int ndigits);\r\n\r\n /**\r\n * @return the number of decimal digits of precision in a real number.\r\n **********************************************************************/\r\n static int digits10();\r\n\r\n /**\r\n * Number of additional decimal digits of precision for real relative to\r\n * double (0 for float).\r\n **********************************************************************/\r\n static int extra_digits();\r\n\r\n /**\r\n * true if the machine is big-endian.\r\n **********************************************************************/\r\n static const bool bigendian = GEOGRAPHICLIB_WORDS_BIGENDIAN;\r\n\r\n /**\r\n * @tparam T the type of the returned value.\r\n * @return π.\r\n **********************************************************************/\r\n template static T pi() {\r\n using std::atan2;\r\n static const T pi = atan2(T(0), T(-1));\r\n return pi;\r\n }\r\n /**\r\n * A synonym for pi().\r\n **********************************************************************/\r\n static real pi() { return pi(); }\r\n\r\n /**\r\n * @tparam T the type of the returned value.\r\n * @return the number of radians in a degree.\r\n **********************************************************************/\r\n template static T degree() {\r\n static const T degree = pi() / 180;\r\n return degree;\r\n }\r\n /**\r\n * A synonym for degree().\r\n **********************************************************************/\r\n static real degree() { return degree(); }\r\n\r\n /**\r\n * Square a number.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return x2.\r\n **********************************************************************/\r\n template static T sq(T x)\r\n { return x * x; }\r\n\r\n /**\r\n * The hypotenuse function avoiding underflow and overflow.\r\n *\r\n * @tparam T the type of the arguments and the returned value.\r\n * @param[in] x\r\n * @param[in] y\r\n * @return sqrt(x2 + y2).\r\n **********************************************************************/\r\n template static T hypot(T x, T y);\r\n\r\n /**\r\n * exp(\\e x) − 1 accurate near \\e x = 0.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return exp(\\e x) − 1.\r\n **********************************************************************/\r\n template static T expm1(T x);\r\n\r\n /**\r\n * log(1 + \\e x) accurate near \\e x = 0.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return log(1 + \\e x).\r\n **********************************************************************/\r\n template static T log1p(T x);\r\n\r\n /**\r\n * The inverse hyperbolic sine function.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return asinh(\\e x).\r\n **********************************************************************/\r\n template static T asinh(T x);\r\n\r\n /**\r\n * The inverse hyperbolic tangent function.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return atanh(\\e x).\r\n **********************************************************************/\r\n template static T atanh(T x);\r\n\r\n /**\r\n * Copy the sign.\r\n *\r\n * @tparam T the type of the argument.\r\n * @param[in] x gives the magitude of the result.\r\n * @param[in] y gives the sign of the result.\r\n * @return value with the magnitude of \\e x and with the sign of \\e y.\r\n *\r\n * This routine correctly handles the case \\e y = −0, returning\r\n * &minus|x|.\r\n **********************************************************************/\r\n template static T copysign(T x, T y);\r\n\r\n /**\r\n * The cube root function.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return the real cube root of \\e x.\r\n **********************************************************************/\r\n template static T cbrt(T x);\r\n\r\n /**\r\n * The remainder function.\r\n *\r\n * @tparam T the type of the arguments and the returned value.\r\n * @param[in] x\r\n * @param[in] y\r\n * @return the remainder of \\e x/\\e y in the range [−\\e y/2, \\e y/2].\r\n **********************************************************************/\r\n template static T remainder(T x, T y);\r\n\r\n /**\r\n * The remquo function.\r\n *\r\n * @tparam T the type of the arguments and the returned value.\r\n * @param[in] x\r\n * @param[in] y\r\n * @param[out] n the low 3 bits of the quotient\r\n * @return the remainder of \\e x/\\e y in the range [−\\e y/2, \\e y/2].\r\n **********************************************************************/\r\n template static T remquo(T x, T y, int* n);\r\n\r\n /**\r\n * The round function.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return \\e x round to the nearest integer (ties round away from 0).\r\n **********************************************************************/\r\n template static T round(T x);\r\n\r\n /**\r\n * The lround function.\r\n *\r\n * @tparam T the type of the argument.\r\n * @param[in] x\r\n * @return \\e x round to the nearest integer as a long int (ties round away\r\n * from 0).\r\n *\r\n * If the result does not fit in a long int, the return value is undefined.\r\n **********************************************************************/\r\n template static long lround(T x);\r\n\r\n /**\r\n * Fused multiply and add.\r\n *\r\n * @tparam T the type of the arguments and the returned value.\r\n * @param[in] x\r\n * @param[in] y\r\n * @param[in] z\r\n * @return xy + z, correctly rounded (on those platforms with\r\n * support for the fma instruction).\r\n *\r\n * On platforms without the fma instruction, no attempt is\r\n * made to improve on the result of a rounded multiplication followed by a\r\n * rounded addition.\r\n **********************************************************************/\r\n template static T fma(T x, T y, T z);\r\n\r\n /**\r\n * Normalize a two-vector.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in,out] x on output set to x/hypot(x, y).\r\n * @param[in,out] y on output set to y/hypot(x, y).\r\n **********************************************************************/\r\n template static void norm(T& x, T& y)\r\n { T h = hypot(x, y); x /= h; y /= h; }\r\n\r\n /**\r\n * The error-free sum of two numbers.\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] u\r\n * @param[in] v\r\n * @param[out] t the exact error given by (\\e u + \\e v) - \\e s.\r\n * @return \\e s = round(\\e u + \\e v).\r\n *\r\n * See D. E. Knuth, TAOCP, Vol 2, 4.2.2, Theorem B. (Note that \\e t can be\r\n * the same as one of the first two arguments.)\r\n **********************************************************************/\r\n template static T sum(T u, T v, T& t);\r\n\r\n /**\r\n * Evaluate a polynomial.\r\n *\r\n * @tparam T the type of the arguments and returned value.\r\n * @param[in] N the order of the polynomial.\r\n * @param[in] p the coefficient array (of size \\e N + 1).\r\n * @param[in] x the variable.\r\n * @return the value of the polynomial.\r\n *\r\n * Evaluate y = ∑n=0..N\r\n * pn xN−n.\r\n * Return 0 if \\e N < 0. Return p0, if \\e N = 0 (even\r\n * if \\e x is infinite or a nan). The evaluation uses Horner's method.\r\n **********************************************************************/\r\n template static T polyval(int N, const T p[], T x)\r\n // This used to employ Math::fma; but that's too slow and it seemed not to\r\n // improve the accuracy noticeably. This might change when there's direct\r\n // hardware support for fma.\r\n { T y = N < 0 ? 0 : *p++; while (--N >= 0) y = y * x + *p++; return y; }\r\n\r\n /**\r\n * Normalize an angle.\r\n *\r\n * @tparam T the type of the argument and returned value.\r\n * @param[in] x the angle in degrees.\r\n * @return the angle reduced to the range (−180°, 180°].\r\n *\r\n * The range of \\e x is unrestricted.\r\n **********************************************************************/\r\n template static T AngNormalize(T x) {\r\n x = remainder(x, T(360)); return x != -180 ? x : 180;\r\n }\r\n\r\n /**\r\n * Normalize a latitude.\r\n *\r\n * @tparam T the type of the argument and returned value.\r\n * @param[in] x the angle in degrees.\r\n * @return x if it is in the range [−90°, 90°], otherwise\r\n * return NaN.\r\n **********************************************************************/\r\n template static T LatFix(T x)\r\n { using std::abs; return abs(x) > 90 ? NaN() : x; }\r\n\r\n /**\r\n * The exact difference of two angles reduced to\r\n * (−180°, 180°].\r\n *\r\n * @tparam T the type of the arguments and returned value.\r\n * @param[in] x the first angle in degrees.\r\n * @param[in] y the second angle in degrees.\r\n * @param[out] e the error term in degrees.\r\n * @return \\e d, the truncated value of \\e y − \\e x.\r\n *\r\n * This computes \\e z = \\e y − \\e x exactly, reduced to\r\n * (−180°, 180°]; and then sets \\e z = \\e d + \\e e where \\e d\r\n * is the nearest representable number to \\e z and \\e e is the truncation\r\n * error. If \\e d = −180, then \\e e > 0; If \\e d = 180, then \\e e\r\n * ≤ 0.\r\n **********************************************************************/\r\n template static T AngDiff(T x, T y, T& e) {\r\n T t, d = AngNormalize(sum(remainder(-x, T(360)),\r\n remainder( y, T(360)), t));\r\n // Here y - x = d + t (mod 360), exactly, where d is in (-180,180] and\r\n // abs(t) <= eps (eps = 2^-45 for doubles). The only case where the\r\n // addition of t takes the result outside the range (-180,180] is d = 180\r\n // and t > 0. The case, d = -180 + eps, t = -eps, can't happen, since\r\n // sum would have returned the exact result in such a case (i.e., given t\r\n // = 0).\r\n return sum(d == 180 && t > 0 ? -180 : d, t, e);\r\n }\r\n\r\n /**\r\n * Difference of two angles reduced to [−180°, 180°]\r\n *\r\n * @tparam T the type of the arguments and returned value.\r\n * @param[in] x the first angle in degrees.\r\n * @param[in] y the second angle in degrees.\r\n * @return \\e y − \\e x, reduced to the range [−180°,\r\n * 180°].\r\n *\r\n * The result is equivalent to computing the difference exactly, reducing\r\n * it to (−180°, 180°] and rounding the result. Note that\r\n * this prescription allows −180° to be returned (e.g., if \\e x\r\n * is tiny and negative and \\e y = 180°).\r\n **********************************************************************/\r\n template static T AngDiff(T x, T y)\r\n { T e; return AngDiff(x, y, e); }\r\n\r\n /**\r\n * Coarsen a value close to zero.\r\n *\r\n * @tparam T the type of the argument and returned value.\r\n * @param[in] x\r\n * @return the coarsened value.\r\n *\r\n * The makes the smallest gap in \\e x = 1/16 − nextafter(1/16, 0) =\r\n * 1/257 for reals = 0.7 pm on the earth if \\e x is an angle in\r\n * degrees. (This is about 1000 times more resolution than we get with\r\n * angles around 90°.) We use this to avoid having to deal with near\r\n * singular cases when \\e x is non-zero but tiny (e.g.,\r\n * 10−200). This converts −0 to +0; however tiny\r\n * negative numbers get converted to −0.\r\n **********************************************************************/\r\n template static T AngRound(T x);\r\n\r\n /**\r\n * Evaluate the sine and cosine function with the argument in degrees\r\n *\r\n * @tparam T the type of the arguments.\r\n * @param[in] x in degrees.\r\n * @param[out] sinx sin(x).\r\n * @param[out] cosx cos(x).\r\n *\r\n * The results obey exactly the elementary properties of the trigonometric\r\n * functions, e.g., sin 9° = cos 81° = − sin 123456789°.\r\n * If x = −0, then \\e sinx = −0; this is the only case where\r\n * −0 is returned.\r\n **********************************************************************/\r\n template static void sincosd(T x, T& sinx, T& cosx);\r\n\r\n /**\r\n * Evaluate the sine function with the argument in degrees\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x in degrees.\r\n * @return sin(x).\r\n **********************************************************************/\r\n template static T sind(T x);\r\n\r\n /**\r\n * Evaluate the cosine function with the argument in degrees\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x in degrees.\r\n * @return cos(x).\r\n **********************************************************************/\r\n template static T cosd(T x);\r\n\r\n /**\r\n * Evaluate the tangent function with the argument in degrees\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x in degrees.\r\n * @return tan(x).\r\n *\r\n * If \\e x = ±90°, then a suitably large (but finite) value is\r\n * returned.\r\n **********************************************************************/\r\n template static T tand(T x);\r\n\r\n /**\r\n * Evaluate the atan2 function with the result in degrees\r\n *\r\n * @tparam T the type of the arguments and the returned value.\r\n * @param[in] y\r\n * @param[in] x\r\n * @return atan2(y, x) in degrees.\r\n *\r\n * The result is in the range (−180° 180°]. N.B.,\r\n * atan2d(±0, −1) = +180°; atan2d(−ε,\r\n * −1) = −180°, for ε positive and tiny;\r\n * atan2d(±0, +1) = ±0°.\r\n **********************************************************************/\r\n template static T atan2d(T y, T x);\r\n\r\n /**\r\n * Evaluate the atan function with the result in degrees\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return atan(x) in degrees.\r\n **********************************************************************/\r\n template static T atand(T x);\r\n\r\n /**\r\n * Evaluate e atanh(e x)\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @param[in] es the signed eccentricity = sign(e2)\r\n * sqrt(|e2|)\r\n * @return e atanh(e x)\r\n *\r\n * If e2 is negative (e is imaginary), the\r\n * expression is evaluated in terms of atan.\r\n **********************************************************************/\r\n template static T eatanhe(T x, T es);\r\n\r\n /**\r\n * tanχ in terms of tanφ\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] tau τ = tanφ\r\n * @param[in] es the signed eccentricity = sign(e2)\r\n * sqrt(|e2|)\r\n * @return τ′ = tanχ\r\n *\r\n * See Eqs. (7--9) of\r\n * C. F. F. Karney,\r\n * \r\n * Transverse Mercator with an accuracy of a few nanometers,\r\n * J. Geodesy 85(8), 475--485 (Aug. 2011)\r\n * (preprint\r\n * arXiv:1002.1417).\r\n **********************************************************************/\r\n template static T taupf(T tau, T es);\r\n\r\n /**\r\n * tanφ in terms of tanχ\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] taup τ′ = tanχ\r\n * @param[in] es the signed eccentricity = sign(e2)\r\n * sqrt(|e2|)\r\n * @return τ = tanφ\r\n *\r\n * See Eqs. (19--21) of\r\n * C. F. F. Karney,\r\n * \r\n * Transverse Mercator with an accuracy of a few nanometers,\r\n * J. Geodesy 85(8), 475--485 (Aug. 2011)\r\n * (preprint\r\n * arXiv:1002.1417).\r\n **********************************************************************/\r\n template static T tauf(T taup, T es);\r\n\r\n /**\r\n * Test for finiteness.\r\n *\r\n * @tparam T the type of the argument.\r\n * @param[in] x\r\n * @return true if number is finite, false if NaN or infinite.\r\n **********************************************************************/\r\n template static bool isfinite(T x);\r\n\r\n /**\r\n * The NaN (not a number)\r\n *\r\n * @tparam T the type of the returned value.\r\n * @return NaN if available, otherwise return the max real of type T.\r\n **********************************************************************/\r\n template static T NaN();\r\n\r\n /**\r\n * A synonym for NaN().\r\n **********************************************************************/\r\n static real NaN() { return NaN(); }\r\n\r\n /**\r\n * Test for NaN.\r\n *\r\n * @tparam T the type of the argument.\r\n * @param[in] x\r\n * @return true if argument is a NaN.\r\n **********************************************************************/\r\n template static bool isnan(T x);\r\n\r\n /**\r\n * Infinity\r\n *\r\n * @tparam T the type of the returned value.\r\n * @return infinity if available, otherwise return the max real.\r\n **********************************************************************/\r\n template static T infinity();\r\n\r\n /**\r\n * A synonym for infinity().\r\n **********************************************************************/\r\n static real infinity() { return infinity(); }\r\n\r\n /**\r\n * Swap the bytes of a quantity\r\n *\r\n * @tparam T the type of the argument and the returned value.\r\n * @param[in] x\r\n * @return x with its bytes swapped.\r\n **********************************************************************/\r\n template static T swab(T x) {\r\n union {\r\n T r;\r\n unsigned char c[sizeof(T)];\r\n } b;\r\n b.r = x;\r\n for (int i = sizeof(T)/2; i--; )\r\n std::swap(b.c[i], b.c[sizeof(T) - 1 - i]);\r\n return b.r;\r\n }\r\n\r\n };\r\n\r\n} // namespace GeographicLib\r\n\r\n#endif // GEOGRAPHICLIB_MATH_HPP\r\n", "meta": {"hexsha": "dc13a1b06c56f39d3d90b50442436ff4fd42cbc1", "size": 25311, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/GeographicLib/Math.hpp", "max_stars_repo_name": "uav4geo/GeographicLib", "max_stars_repo_head_hexsha": "4427486381b405a02127688f1e7257cf85be912b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/GeographicLib/Math.hpp", "max_issues_repo_name": "uav4geo/GeographicLib", "max_issues_repo_head_hexsha": "4427486381b405a02127688f1e7257cf85be912b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/GeographicLib/Math.hpp", "max_forks_repo_name": "uav4geo/GeographicLib", "max_forks_repo_head_hexsha": "4427486381b405a02127688f1e7257cf85be912b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0601851852, "max_line_length": 80, "alphanum_fraction": 0.4997827032, "num_tokens": 6224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5467381519846138, "lm_q2_score": 0.5467381519846138, "lm_q1q2_score": 0.2989226068355507}} {"text": "// File: insert.cpp\n\n#include \n#include \n\nusing namespace mtl;\n\ntemplate \nvoid fill(Matrix& m)\n{\n // Matrices are not initialized by default\n m= 0.0;\n\n // Create inserter for matrix m\n mat::inserter ins(m);\n \n // Insert value in m[0][0]\n ins[0][0] << 2.0;\n ins[1][2] << 0.5;\n ins[2][1] << 3.0;\n\n // Destructor of ins sets final state of m\n}\n\ntemplate \nvoid modify(Matrix& m)\n{\n // Type of m's elements\n typedef typename Collection::value_type value_type;\n\n // Create inserter for matrix m\n // Existing values are not overwritten but inserted\n mat::inserter > ins(m, 3);\n \n // Increment value in m[0][0]\n ins[0][0] << 1.0;\n\n // Elements that doesn't exist (in sparse matrices) are inserted\n ins[1][1] << 2.5;\n ins[2][1] << 1.0;\n ins[2][2] << 4.0;\n\n // Destructor of ins sets final state of m\n}\n\nint main(int, char**)\n{\n // Matrices of different types\n compressed2D A(3, 3);\n dense2D B(3, 3);\n morton_dense C(3, 3);\n\n // Fill the matrices generically\n fill(A); fill(B); fill(C);\n std::cout << \"A is \\n\" << A << \"\\nB is \\n\" << B << \"\\nC is \\n\" << C;\n\n // Modify the matrices generically\n modify(A); modify(B); modify(C);\n std::cout << \"\\n\\nAfter modification:\\nA is \\n\" << A \n\t << \"\\nB is \\n\" << B << \"\\nC is \\n\" << C;\n\n return 0;\n}\n\n", "meta": {"hexsha": "7366b95b321f7fef1306a9e0bbea438359fad4aa", "size": 1525, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/numeric/mtl/examples/insert.cpp", "max_stars_repo_name": "lit-uriy/mtl4-mirror", "max_stars_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_stars_repo_licenses": ["MTLL"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2019-03-26T15:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T10:00:45.000Z", "max_issues_repo_path": "libs/numeric/mtl/examples/insert.cpp", "max_issues_repo_name": "lit-uriy/mtl4-mirror", "max_issues_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_issues_repo_licenses": ["MTLL"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-04-17T12:35:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-03T15:46:25.000Z", "max_forks_repo_path": "libs/numeric/mtl/examples/insert.cpp", "max_forks_repo_name": "lit-uriy/mtl4-mirror", "max_forks_repo_head_hexsha": "37cf7c2847165d3537cbc3400cb5fde6f80e3d8b", "max_forks_repo_licenses": ["MTLL"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-12-01T13:40:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T08:39:54.000Z", "avg_line_length": 23.4615384615, "max_line_length": 72, "alphanum_fraction": 0.5744262295, "num_tokens": 484, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.2988502769805688}} {"text": "// Copyright Thijs van den Berg, 2008.\r\n// Copyright John Maddock 2008.\r\n// Copyright Paul A. Bristow 2008.\r\n\r\n// Use, modification and distribution are subject to the\r\n// Boost Software License, Version 1.0. (See accompanying file\r\n// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\r\n\r\n// This module implements the Laplace distribution.\r\n// Weisstein, Eric W. \"Laplace Distribution.\" From MathWorld--A Wolfram Web Resource.\r\n// http://mathworld.wolfram.com/LaplaceDistribution.html\r\n// http://en.wikipedia.org/wiki/Laplace_distribution\r\n//\r\n// Abramowitz and Stegun 1972, p 930\r\n// http://www.math.sfu.ca/~cbm/aands/page_930.htm\r\n\r\n#ifndef BOOST_STATS_LAPLACE_HPP\r\n#define BOOST_STATS_LAPLACE_HPP\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\nnamespace boost{ namespace math{\r\n\r\ntemplate >\r\nclass laplace_distribution\r\n{\r\npublic:\r\n // ----------------------------------\r\n // public Types\r\n // ----------------------------------\r\n typedef RealType value_type;\r\n typedef Policy policy_type;\r\n\r\n // ----------------------------------\r\n // Constructor(s)\r\n // ----------------------------------\r\n laplace_distribution(RealType location = 0, RealType scale = 1)\r\n : m_location(location), m_scale(scale)\r\n {\r\n RealType result;\r\n check_parameters(\"boost::math::laplace_distribution<%1%>::laplace_distribution()\", &result);\r\n }\r\n\r\n\r\n // ----------------------------------\r\n // Public functions\r\n // ----------------------------------\r\n\r\n RealType location() const\r\n {\r\n return m_location;\r\n }\r\n\r\n RealType scale() const\r\n {\r\n return m_scale;\r\n }\r\n\r\n bool check_parameters(const char* function, RealType* result) const\r\n {\r\n if(false == detail::check_scale(function, m_scale, result, Policy())) return false;\r\n if(false == detail::check_location(function, m_location, result, Policy())) return false;\r\n return true;\r\n }\r\n\r\n\r\nprivate:\r\n RealType m_location;\r\n RealType m_scale;\r\n\r\n}; // class laplace_distribution\r\n\r\n\r\n\r\n//\r\n// Convenient type synonym\r\n//\r\ntypedef laplace_distribution laplace;\r\n\r\n//\r\n// Non member functions\r\n//\r\ntemplate \r\ninline const std::pair range(const laplace_distribution&)\r\n{\r\n using boost::math::tools::max_value;\r\n return std::pair(-max_value(), max_value());\r\n}\r\n\r\ntemplate \r\ninline const std::pair support(const laplace_distribution&)\r\n{\r\n using boost::math::tools::max_value;\r\n return std::pair(-max_value(), max_value());\r\n}\r\n\r\ntemplate \r\ninline RealType pdf(const laplace_distribution& dist, const RealType& x)\r\n{\r\n BOOST_MATH_STD_USING // for ADL of std functions\r\n\r\n // Checking function argument\r\n RealType result;\r\n const char* function = \"boost::math::pdf(const laplace_distribution<%1%>&, %1%))\";\r\n if (false == dist.check_parameters(function, &result)) return result;\r\n if (false == detail::check_x(function, x, &result, Policy())) return result;\r\n\r\n // Special pdf values\r\n if((boost::math::isinf)(x))\r\n return 0; // pdf + and - infinity is zero.\r\n\r\n // General case\r\n RealType scale( dist.scale() );\r\n RealType location( dist.location() );\r\n\r\n RealType exponent = x - location;\r\n if (exponent>0) exponent = -exponent;\r\n exponent /= scale;\r\n\r\n result = exp(exponent);\r\n result /= 2 * scale;\r\n\r\n return result;\r\n} // pdf\r\n\r\ntemplate \r\ninline RealType cdf(const laplace_distribution& dist, const RealType& x)\r\n{\r\n BOOST_MATH_STD_USING // for ADL of std functions\r\n\r\n // Checking function argument\r\n RealType result;\r\n const char* function = \"boost::math::cdf(const laplace_distribution<%1%>&, %1%)\";\r\n if (false == dist.check_parameters(function, &result)) return result;\r\n if (false == detail::check_x(function, x, &result, Policy())) return result;\r\n\r\n // Special cdf values\r\n if((boost::math::isinf)(x))\r\n {\r\n if(x < 0) return 0; // -infinity\r\n return 1; // + infinity\r\n }\r\n\r\n // General cdf values\r\n RealType scale( dist.scale() );\r\n RealType location( dist.location() );\r\n\r\n if (x < location)\r\n result = exp( (x-location)/scale )/2;\r\n else\r\n result = 1 - exp( (location-x)/scale )/2;\r\n\r\n return result;\r\n} // cdf\r\n\r\n\r\ntemplate \r\ninline RealType quantile(const laplace_distribution& dist, const RealType& p)\r\n{\r\n BOOST_MATH_STD_USING // for ADL of std functions\r\n\r\n // Checking function argument\r\n RealType result;\r\n const char* function = \"boost::math::quantile(const laplace_distribution<%1%>&, %1%)\";\r\n if (false == dist.check_parameters(function, &result)) return result;\r\n if(false == detail::check_probability(function, p, &result, Policy())) return result;\r\n\r\n // extreme values\r\n if(p == 0) return -std::numeric_limits::infinity();\r\n if(p == 1) return std::numeric_limits::infinity();\r\n\r\n // Calculate Quantile\r\n RealType scale( dist.scale() );\r\n RealType location( dist.location() );\r\n\r\n if (p - 0.5 < 0.0)\r\n result = location + scale*log( static_cast(p*2) );\r\n else\r\n result = location - scale*log( static_cast(-p*2 + 2) );\r\n\r\n return result;\r\n} // quantile\r\n\r\n\r\ntemplate \r\ninline RealType cdf(const complemented2_type, RealType>& c)\r\n{\r\n BOOST_MATH_STD_USING // for ADL of std functions\r\n\r\n RealType scale = c.dist.scale();\r\n RealType location = c.dist.location();\r\n RealType x = c.param;\r\n\r\n // Checking function argument\r\n RealType result;\r\n const char* function = \"boost::math::cdf(const complemented2_type, %1%>&)\";\r\n if(false == detail::check_x(function, x, &result, Policy()))return result;\r\n\r\n // Calculate cdf\r\n\r\n // Special cdf value\r\n if((boost::math::isinf)(x))\r\n {\r\n if(x < 0) return 1; // cdf complement -infinity is unity.\r\n return 0; // cdf complement +infinity is zero\r\n }\r\n\r\n // Cdf interval value\r\n if (-x < location)\r\n result = exp( (-x-location)/scale )/2;\r\n else\r\n result = 1 - exp( (location+x)/scale )/2;\r\n\r\n return result;\r\n} // cdf complement\r\n\r\n\r\ntemplate \r\ninline RealType quantile(const complemented2_type, RealType>& c)\r\n{\r\n BOOST_MATH_STD_USING // for ADL of std functions\r\n\r\n // Calculate quantile\r\n RealType scale = c.dist.scale();\r\n RealType location = c.dist.location();\r\n RealType q = c.param;\r\n\r\n // Checking function argument\r\n RealType result;\r\n const char* function = \"quantile(const complemented2_type, %1%>&)\";\r\n if(false == detail::check_probability(function, q, &result, Policy())) return result;\r\n\r\n\r\n // extreme values\r\n if(q == 0) return std::numeric_limits::infinity();\r\n if(q == 1) return -std::numeric_limits::infinity();\r\n\r\n if (0.5 - q < 0.0)\r\n result = location + scale*log( static_cast(-q*2 + 2) );\r\n else\r\n result = location - scale*log( static_cast(q*2) );\r\n\r\n\r\n return result;\r\n} // quantile\r\n\r\ntemplate \r\ninline RealType mean(const laplace_distribution& dist)\r\n{\r\n return dist.location();\r\n}\r\n\r\ntemplate \r\ninline RealType standard_deviation(const laplace_distribution& dist)\r\n{\r\n return constants::root_two() * dist.scale();\r\n}\r\n\r\ntemplate \r\ninline RealType mode(const laplace_distribution& dist)\r\n{\r\n return dist.location();\r\n}\r\n\r\ntemplate \r\ninline RealType median(const laplace_distribution& dist)\r\n{\r\n return dist.location();\r\n}\r\n\r\ntemplate \r\ninline RealType skewness(const laplace_distribution& /*dist*/)\r\n{\r\n return 0;\r\n}\r\n\r\ntemplate \r\ninline RealType kurtosis(const laplace_distribution& /*dist*/)\r\n{\r\n return 6;\r\n}\r\n\r\ntemplate \r\ninline RealType kurtosis_excess(const laplace_distribution& /*dist*/)\r\n{\r\n return 3;\r\n}\r\n\r\n} // namespace math\r\n} // namespace boost\r\n\r\n// This include must be at the end, *after* the accessors\r\n// for this distribution have been defined, in order to\r\n// keep compilers that support two-phase lookup happy.\r\n#include \r\n\r\n#endif // BOOST_STATS_LAPLACE_HPP\r\n\r\n\r\n", "meta": {"hexsha": "c8814d99e5195e28e687754eeef4ab5e72414341", "size": 9014, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Compiler/boost/boost/math/distributions/laplace.hpp", "max_stars_repo_name": "davidov541/MiniC", "max_stars_repo_head_hexsha": "d3b16a1568b97a4d801880b110a8be04fe848adb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2015-04-16T01:05:53.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-26T07:38:43.000Z", "max_issues_repo_path": "LibsExternes/Includes/boost/math/distributions/laplace.hpp", "max_issues_repo_name": "benkaraban/anima-games-engine", "max_issues_repo_head_hexsha": "8aa7a5368933f1b82c90f24814f1447119346c3b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2017-04-05T01:56:28.000Z", "max_issues_repo_issues_event_max_datetime": "2017-04-05T01:56:28.000Z", "max_forks_repo_path": "LibsExternes/Includes/boost/math/distributions/laplace.hpp", "max_forks_repo_name": "benkaraban/anima-games-engine", "max_forks_repo_head_hexsha": "8aa7a5368933f1b82c90f24814f1447119346c3b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.7491749175, "max_line_length": 105, "alphanum_fraction": 0.6575327269, "num_tokens": 2187, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5389832206876841, "lm_q2_score": 0.5544704649604273, "lm_q1q2_score": 0.2988502769805688}} {"text": "\n/*\n * OptimalControlProblem.hpp\n *\n * Created on: July 7, 2019\n * Author: Quincy Jones\n *\n * Copyright (c) <2019> \n * Permission is hereby granted, free of charge, to any person obtaining a\n * copy of this software and associated documentation files (the \"Software\"),\n * to deal in the Software without restriction, including without limitation\n * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n * and/or sell copies of the Software, and to permit persons to whom the Software\n * is furnished to do so, subject to the following conditions:\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n#ifndef NOMAD_CORE_OPTIMALCONTROL_OPTIMALCONTROLPROBLEM_H_\n#define NOMAD_CORE_OPTIMALCONTROL_OPTIMALCONTROLPROBLEM_H_\n\n#include \n#include \n#include \n\nnamespace OptimalControl\n{\n\n class OptimalControlProblem\n {\n\n public:\n // Base Class Optimal Control Problem\n // N = Prediction Steps\n // T = Horizon Length\n // num_states = Number of States of OCP\n // num_inputs = Number of Inputs of OCP\n OptimalControlProblem(const unsigned int N, const double T, const unsigned int num_states, const unsigned int num_inputs, const unsigned int max_iterations = 1000);\n\n // Solve\n virtual void Solve() = 0;\n\n // Get System State Trajectory Vector\n // TODO: Compute this depending on U solutions. X_ = Ax+Bu\n // TODO: Make pure virtual\n virtual Eigen::MatrixXd X() const { return X_; }\n\n //Get Current Input Sequence Solution\n Eigen::MatrixXd U() const { return U_; }\n\n // Set Weight Matrices\n virtual void SetWeights(const Eigen::VectorXd &Q, const Eigen::VectorXd &R)\n {\n // TODO: Verify Vector Size Matches correct state and inputs\n Q_ = Q.matrix().asDiagonal().toDenseMatrix();\n R_ = R.matrix().asDiagonal().toDenseMatrix();\n }\n\n // Set Problem Initial Condition\n void SetInitialCondition(const Eigen::VectorXd &x_0) { x_0_ = x_0; }\n\n // Set Reference Trajectory\n void SetReference(const Eigen::MatrixXd &X_ref) { X_ref_ = X_ref; }\n\n // Time step sample time\n double SampleTime() const { return T_s_; }\n\n // Prediction Horizon Steps\n int N() const { return N_; }\n\n protected:\n Eigen::VectorXd x_0_; // Current State/Initial Condition\n Eigen::MatrixXd X_ref_; // Reference Trajectory\n\n Eigen::MatrixXd X_; // System State Trajectory\n Eigen::MatrixXd U_; // Optimal Control Input Sequence Solution\n\n Eigen::MatrixXd Q_; // State Weights\n Eigen::MatrixXd R_; // Input Weights\n\n int num_states_; // Number of System States\n int num_inputs_; // Number of System Inputs\n\n int N_; // Number of Prediction Steps\n\n double T_s_; // Sample Time\n double T_; // Horizon Length\n\n qpOASES::int_t max_iterations_; // Max Iterations for Solver\n qpOASES::int_t solver_iterations_; // Total number of Solver iterations for solution\n double solver_time_; // Total time for Solver to compute a solution\n\n bool solved_;\n // TODO:\n // Infeasible, BlahBlah\n };\n} // namespace OptimalControl\n\nnamespace OptimalControl\n{\n namespace LinearOptimalControl\n {\n class LinearOptimalControlProblem : public OptimalControlProblem\n {\n public:\n // Base Class Linear Optimal Control Problem\n // N = Prediction Steps\n // T = Horizon Length\n // num_states = Number of States of OCP\n // num_inputs = Number of Inputs of OCP\n // max_iterations = Maximum number of solver iterations\n LinearOptimalControlProblem(const unsigned int N,\n const double T,\n const unsigned int num_states,\n const unsigned int num_inputs,\n const unsigned int max_iterations = 1000);\n\n // Set Model Matrices\n void SetModelMatrices(const Eigen::MatrixXd &A, const Eigen::MatrixXd &B)\n {\n A_ = A;\n B_ = B;\n }\n\n // Solve\n virtual void Solve();\n\n protected:\n Eigen::MatrixXd A_; // System State Transition Matrix\n Eigen::MatrixXd B_; // Control Input Matrix\n };\n } // namespace LinearOptimalControl\n} // namespace OptimalControl\n\n#endif // NOMAD_CORE_OPTIMALCONTROL_OPTIMALCONTROLPROBLEM_H_\n", "meta": {"hexsha": "e0445755a03887bff16897d2ee2db6949d7ef63a", "size": 5237, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "Software/Core/OptimalControl/include/OptimalControl/OptimalControlProblem.hpp", "max_stars_repo_name": "implementedrobotics/Nomad", "max_stars_repo_head_hexsha": "de8c27ed79cdcde59b1fd6e9a0865d29b84b7d58", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31.0, "max_stars_repo_stars_event_min_datetime": "2019-08-11T18:24:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T01:22:55.000Z", "max_issues_repo_path": "Software/Core/OptimalControl/include/OptimalControl/OptimalControlProblem.hpp", "max_issues_repo_name": "implementedrobotics/Nomad", "max_issues_repo_head_hexsha": "de8c27ed79cdcde59b1fd6e9a0865d29b84b7d58", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 15.0, "max_issues_repo_issues_event_min_datetime": "2019-05-29T12:57:20.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-29T02:26:06.000Z", "max_forks_repo_path": "Software/Core/OptimalControl/include/OptimalControl/OptimalControlProblem.hpp", "max_forks_repo_name": "implementedrobotics/Nomad", "max_forks_repo_head_hexsha": "de8c27ed79cdcde59b1fd6e9a0865d29b84b7d58", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2019-08-12T03:05:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-09T05:34:16.000Z", "avg_line_length": 37.1418439716, "max_line_length": 172, "alphanum_fraction": 0.6408248998, "num_tokens": 1123, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5312093733737563, "lm_q2_score": 0.5621765008857982, "lm_q1q2_score": 0.2986334267609958}} {"text": "#define NO_IMPORT_ARRAY\n\n#include \n#include \n#include \n#include \n#include \nextern \"C\" {\n #include \n // Additional prototypes for Fortran LAPACK routines.\n // sposv: solve Ax = b for A positive definite.\n void sposv_(const char* uplo, int* n, int* nrhs, float* a, int* lda,\n float* b, int* ldb, int* info );\n}\n\n#include \n\n#include \n#include \"so3g_numpy.h\"\n#include \"numpy_assist.h\"\n#include \"Ranges.h\"\n\n// TODO: Generalize to double precision too.\n// This implements Jon's noise model for ACT. It takes in\n// * ft[ndet,nfreq] the fourier transform of the time-ordered data\n// * bins[nbin,{from,to}] the start and end of each bin\n// * iD[nbin,ndet] the inverse uncorrelated variance for each detector per bin\n// * iV[nbin,ndet,nvec] matrix representing the scaled eivenvectors per bin\nvoid nmat_detvecs_apply(const bp::object & ft, const bp::object & bins, const bp::object & iD, const bp::object & iV, float s, float norm) {\n\t// Should pass in this too\n\tBufferWrapper ft_buf (\"ft\", ft, false, std::vector{-1,-1});\n\tBufferWrapper bins_buf(\"bins\", bins, false, std::vector{-1, 2});\n\tint ndet = ft_buf->shape[0], nmode = ft_buf->shape[1], nbin = bins_buf->shape[0];\n\tBufferWrapper iD_buf (\"iD\", iD, false, std::vector{nbin,ndet});\n\tBufferWrapper iV_buf (\"iV\", iV, false, std::vector{nbin,ndet,-1});\n\tint nvec = iV_buf->shape[2];\n\tif (ft_buf->strides[1] != ft_buf->itemsize || ft_buf->strides[0] != ft_buf->itemsize*nmode)\n\t\tthrow buffer_exception(\"ft must be C-contiguous along last axis\");\n\tif (bins_buf->strides[1] != bins_buf->itemsize || bins_buf->strides[0] != bins_buf->itemsize*2)\n\t\tthrow buffer_exception(\"bins must be C-contiguous along last axis\");\n\tif (iD_buf->strides[1] != iD_buf->itemsize || iD_buf->strides[0] != iD_buf->itemsize*ndet)\n\t\tthrow buffer_exception(\"iD must be C-contiguous along last axis\");\n\tif (iV_buf->strides[2] != iV_buf->itemsize || iV_buf->strides[1] != iV_buf->itemsize*nvec || iV_buf->strides[0] != iV_buf->itemsize*nvec*ndet)\n\t\tthrow buffer_exception(\"iV must be C-contiguous along last axis\");\n\t// Internally we work with a real view of ft, with twice as many elements to compensate\n\t//int nmode = 2*nfreq;\n\tfloat * ft_ = (float*) ft_buf->buf;\n\tint32_t * bins_ = (int32_t*) bins_buf->buf;\n\tfloat * iD_ = (float*) iD_buf->buf;\n\tfloat * iV_ = (float*) iV_buf->buf;\n\n\t// Ok, actually do the work\n\tfor(int bi = 0; bi < nbin; bi++) {\n\t\tint b1 = min(2*bins_[2*bi+0],nmode-1);\n\t\tint b2 = min(2*bins_[2*bi+1],nmode);\n\t\tint nm = b2-b1;\n\t\tfloat * biD = iD_ + bi*ndet;\n\t\tfloat * biV = iV_ + bi*ndet*nvec;\n\n\t\t// what I want to do\n\t\t// ft = ftod[:,b[0]:b[1]]\n\t\t// iD = self.iD[bi]/norm\n\t\t// iV = self.iV[bi]/norm**0.5\n\t\t// ft[:] = iD[:,None]*ft + self.s*iV.dot(iV.T.dot(ft))\n\t\t// So first do iV.T [nvec,ndet] dot ft [ndet,nm] -> Q [nvec,nm]\n\t\tfloat * Q = new float[nvec*nm];\n\t\tcblas_sgemm(CblasRowMajor, CblasTrans, CblasNoTrans, nvec, nm, ndet, 1.0f, biV, nvec, ft_+b1, nmode, 0.0f, Q, nm);\n\t\t// Handle the uncorrelated part\n\t\t//#pragma omp parallel for\n\t\tfor(int di = 0; di < ndet; di++)\n\t\t\tfor(int i = b1; i < b2; i++)\n\t\t\t\tft_[di*nmode+i] *= biD[di]/norm;\n\t\t// Do ft += s*iV[ndet,nvec] dot Q [nvec,nm]\n\t\tcblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, ndet, nm, nvec, s/norm, biV, nvec, Q, nm, 1.0f, ft_+b1, nmode);\n\t\tdelete [] Q;\n\t}\n}\n\n// Support of maximum-liklihood sample cut handling. This got a bit long, so it should\n// probably be moved into its own file.\n\n// Forward declarations of helper functions\nint get_dtype(const bp::object &);\nint pcut_full_measure_helper(const vector &);\ntemplate void pcut_full_tod2vals_helper(const vector &, T *, int, int, T *);\ntemplate void pcut_full_vals2tod_helper(const vector &, T *, int, int, T *);\nint pcut_poly_measure_helper(const vector &, int, int nmax);\ntemplate void pcut_poly_tod2vals_helper(const vector &, int, int, T *, int, int, T *);\ntemplate void pcut_poly_vals2tod_helper(const vector &, int, int, T *, int, int, T *);\ntemplate void pcut_clear_helper(const vector &, T *, int, int);\n\n// The main cuts processing function. In Maximum-likelihood map-making cuts are handled\n// as special degrees of freedom, and are part of the pointing matrix. This function\n// provides the operations corresponding to the cuts part of the pointing matrix P and\n// P'. In particular, operation == \"insert\" corresponds to the model-to-data matrix P,\n// while operation == \"extract\" corresponds to the data-to-model matrix P'. Additionally,\n// we provide operation == \"measure\", which doesn't touch any of the arrays, and just returns\n// how long the vals argument should be.\n//\n// Note that \"extract\" does not in general estimate the coefficients of the model. It just does\n// P'd, while the coefficients would (in the absence of any sky signal etc) be (P'P)'P'd.\n//\n// Arguments:\n// range_matrix: the .ranges member of a python RangesMatrix\n// operation: \"measure\", \"insert\" or \"extract\"\n// model: The type of model used\n// * \"full\": One degree of freedom per sample\n// * \"poly\": Model is a legendre polynomial in each range.\n// Order of poly determined by params[\"resolution\"] (samples per order) and params[\"nmax\"] (max order)\n// tod: numpy array with shape [ndet,nsamp] of dtype float32 or float64\n// vals: numpy array with shape [:] of same dtype as tod. Holds the model degrees of freedom.\n//\n// TODO: To be able to process cuts in parallel, we need a lookup table for where in vals each\n// cut range starts. This will be fast enough to build on the fly. Would pass this as an extra\n// argument to the helper functions.\n\nint process_cuts(const bp::object & range_matrix, const std::string & operation, const std::string & model, const bp::dict & params, const bp::object & tod, const bp::object & vals) {\n\tauto ranges = extract_ranges(range_matrix);\n\t// Decoding these up here lets us avoid some duplication later\n\tint resolution, nmax;\n\tif (model == \"full\") {}\n\telse if(model == \"poly\") {\n\t\tresolution = bp::extract(params.get(\"resolution\"));\n\t\tnmax = bp::extract(params.get(\"nmax\"));\n\t} else throw general_exception(\"process_cuts model can only be 'full' or 'poly'\");\n\n\tif(operation == \"measure\") {\n\t\tif (model == \"full\") return pcut_full_measure_helper(ranges);\n\t\telse if(model == \"poly\") return pcut_poly_measure_helper(ranges, resolution, nmax);\n\t} else {\n\t\tint dtype = get_dtype(tod);\n\t\tif(dtype == NPY_FLOAT) {\n\t\t\tBufferWrapper tod_buf (\"tod\", tod, false, std::vector{-1,-1});\n\t\t\tBufferWrapper vals_buf (\"vals\", vals, false, std::vector{-1});\n\t\t\tint ndet = tod_buf->shape[0], nsamp = tod_buf->shape[1];\n\t\t\tif(operation == \"insert\") {\n\t\t\t\tif (model == \"full\")\n\t\t\t\t\tpcut_full_vals2tod_helper(ranges, (float*)tod_buf->buf, ndet, nsamp, (float*) vals_buf->buf);\n\t\t\t\telse if(model == \"poly\")\n\t\t\t\t\tpcut_poly_vals2tod_helper(ranges, resolution, nmax, (float*)tod_buf->buf, ndet, nsamp, (float*) vals_buf->buf);\n\t\t\t} else if(operation == \"extract\") {\n\t\t\t\tif (model == \"full\")\n\t\t\t\t\tpcut_full_tod2vals_helper(ranges, (float*)tod_buf->buf, ndet, nsamp, (float*) vals_buf->buf);\n\t\t\t\telse if(model == \"poly\")\n\t\t\t\t\tpcut_poly_tod2vals_helper(ranges, resolution, nmax, (float*)tod_buf->buf, ndet, nsamp, (float*) vals_buf->buf);\n\t\t\t} else if(operation == \"clear\") {\n\t\t\t\tpcut_clear_helper(ranges, (float*)tod_buf->buf, ndet, nsamp);\n\t\t\t} else throw general_exception(\"process_cuts operation can only be 'measure', 'insert' or 'extract'\");\n\t\t} else if(dtype == NPY_DOUBLE) {\n\t\t\tBufferWrapper tod_buf (\"tod\", tod, false, std::vector{-1,-1});\n\t\t\tBufferWrapper vals_buf (\"vals\", vals, false, std::vector{-1});\n\t\t\tint ndet = tod_buf->shape[0], nsamp = tod_buf->shape[1];\n\t\t\tif(operation == \"insert\") {\n\t\t\t\tif (model == \"full\")\n\t\t\t\t\tpcut_full_vals2tod_helper(ranges, (double*)tod_buf->buf, ndet, nsamp, (double*) vals_buf->buf);\n\t\t\t\telse if(model == \"poly\")\n\t\t\t\t\tpcut_poly_vals2tod_helper(ranges, resolution, nmax, (double*)tod_buf->buf, ndet, nsamp, (double*) vals_buf->buf);\n\t\t\t} else if(operation == \"extract\") {\n\t\t\t\tif (model == \"full\")\n\t\t\t\t\tpcut_full_tod2vals_helper(ranges, (double*)tod_buf->buf, ndet, nsamp, (double*) vals_buf->buf);\n\t\t\t\telse if(model == \"poly\")\n\t\t\t\t\tpcut_poly_tod2vals_helper(ranges, resolution, nmax, (double*)tod_buf->buf, ndet, nsamp, (double*) vals_buf->buf);\n\t\t\t} else if(operation == \"clear\") {\n\t\t\t\tpcut_clear_helper(ranges, (float*)tod_buf->buf, ndet, nsamp);\n\t\t\t} else throw general_exception(\"process_cuts operation can only be 'measure', 'insert' or 'extract'\");\n\t\t} else throw general_exception(\"process_cuts only supports float32 and float64\");\n\t}\n\treturn 0;\n}\n\n// Helpers for the cuts\n\nint get_dtype(const bp::object & arr) {\n\tPyObject *ob = PyArray_FromAny(arr.ptr(), NULL, 0, 0, 0, NULL);\n\tif (ob == NULL) throw exception();\n\tPyArrayObject * a = reinterpret_cast(ob);\n\tint res = PyArray_TYPE(a);\n\tPy_DECREF(a);\n\treturn PyArray_TYPE(a);\n}\n\n// This is all from Jon's work for ACT.\nint get_npoly(int gapsize, int resolution, int nmax) {\n\tif(nmax < 1) nmax = 1;\n\tif (gapsize <= 1) return min(1, nmax);\n\telse if(gapsize <= 3) return min(2, nmax);\n\telse if(gapsize <= 6) return min(3, nmax);\n\telse if(gapsize <= 20) return min(4, nmax);\n\telse return min(5 + gapsize/resolution, nmax);\n}\n\n// Full cut treatment, with one degree of freedom for each sample in the cut\nint pcut_full_measure_helper(const vector & rangemat) {\n\tint n = 0;\n\tfor(int di = 0; di < rangemat.size(); di++)\n\t\tfor (auto const &r: rangemat[di].segments)\n\t\t\tn += r.second-r.first;\n\treturn n;\n}\ntemplate \nvoid pcut_full_tod2vals_helper(const vector & rangemat, T * tod, int ndet, int nsamp, T * vals) {\n\tint i = 0;\n\tfor(int di = 0; di < rangemat.size(); di++)\n\t\tfor (auto const &r: rangemat[di].segments)\n\t\t\tfor(int j = r.first; j < r.second; j++, i++)\n\t\t\t\tvals[i] = tod[di*nsamp+j];\n}\ntemplate \nvoid pcut_full_vals2tod_helper(const vector & rangemat, T * tod, int ndet, int nsamp, T * vals) {\n\tint i = 0;\n\tfor(int di = 0; di < rangemat.size(); di++)\n\t\tfor (auto const &r: rangemat[di].segments)\n\t\t\tfor(int j = r.first; j < r.second; j++, i++)\n\t\t\t\ttod[di*nsamp+j] = vals[i];\n}\n\n// Polynomial cut treatment\nint pcut_poly_measure_helper(const vector & rangemat, int resolution, int nmax) {\n\tint n = 0;\n\tfor(int di = 0; di < rangemat.size(); di++)\n\t\tfor (auto const &r: rangemat[di].segments)\n\t\t\tn += get_npoly(r.second-r.first, resolution, nmax);\n\treturn n;\n}\ntemplate \nvoid pcut_poly_tod2vals_helper(const vector & rangemat, int resolution, int nmax, T * tod, int ndet, int nsamp, T * vals) {\n\tint i = 0;\n\tfor(int di = 0; di < rangemat.size(); di++) {\n\t\tfor (auto const &r: rangemat[di].segments) {\n\t\t\tint np = get_npoly(r.second-r.first, resolution, nmax);\n\t\t\tif(np <= 1) {\n\t\t\t\tfor(int s = r.first; s < r.second; s++)\n\t\t\t\t\tvals[i] += tod[di*nsamp+s];\n\t\t\t\ti++;\n\t\t\t} else {\n\t\t\t\tfor(int p = 0; p < np; p++) vals[i+p] = 0;\n\t\t\t\tfor(int s = r.first; s < r.second; s++) {\n\t\t\t\t\tT x = -1 + 2*(s-r.first)/T(r.second-r.first-1);\n\t\t\t\t\tT t = tod[di*nsamp+s];\n\t\t\t\t\tvals[i] += t;\n\t\t\t\t\tif(np > 1) vals[i+1] += t*x;\n\t\t\t\t\tif(np > 2) {\n\t\t\t\t\t\tT Pa = x, Pb = 1, Pc = 0;\n\t\t\t\t\t\tfor(int p = 2; p < np; p++) {\n\t\t\t\t\t\t\tPc = Pb; Pb = Pa; Pa = ((2*p-1)*x*Pb-(p-1)*Pc)/p;\n\t\t\t\t\t\t\tvals[i+p] += t*Pa;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\ti += np;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\ntemplate \nvoid pcut_poly_vals2tod_helper(const vector & rangemat, int resolution, int nmax, T * tod, int ndet, int nsamp, T * vals) {\n\tint i = 0;\n\tfor(int di = 0; di < rangemat.size(); di++) {\n\t\tfor (auto const &r: rangemat[di].segments) {\n\t\t\tint np = get_npoly(r.second-r.first, resolution, nmax);\n\t\t\tif(np <= 1) {\n\t\t\t\tfor(int s = r.first; s < r.second; s++)\n\t\t\t\t\ttod[di*nsamp+s] = vals[i];\n\t\t\t\ti++;\n\t\t\t} else {\n\t\t\t\tfor(int s = r.first; s < r.second; s++) {\n\t\t\t\t\tT x = -1 + 2*(s-r.first)/T(r.second-r.first-1);\n\t\t\t\t\tT t = vals[i];\n\t\t\t\t\tif(np > 1) t += x*vals[i+1];\n\t\t\t\t\tif(np > 2) {\n\t\t\t\t\t\tT Pa = x, Pb = 1, Pc = 0;\n\t\t\t\t\t\tfor(int p = 2; p < np; p++) {\n\t\t\t\t\t\t\tPc = Pb; Pb = Pa; Pa = ((2*p-1)*x*Pb-(p-1)*Pc)/p;\n\t\t\t\t\t\t\tt += Pa*vals[i+p];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\ttod[di*nsamp+s] = t;\n\t\t\t\t\ti += np;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\ntemplate \nvoid pcut_clear_helper(const vector & rangemat, T * tod, int ndet, int nsamp) {\n\t#pragma omp parallel for\n\tfor(int di = 0; di < rangemat.size(); di++)\n\t\tfor (auto const &r: rangemat[di].segments)\n\t\t\tfor(int s = r.first; s < r.second; s++)\n\t\t\t\ttod[di*nsamp+s] = 0;\n}\n\n\n// get_gap_fill_poly_single\n//\n// Single detector processor for get_gap_fill_poly. Fit polynomials\n// to each stretch of data in \"gaps\". Requires square matrix a and\n// vector b to be preallocated for ncoeff.\n//\n// The arguments (inplace, extract) behave like this:\n//\n// (true, valid): The data are replaced with the model, and the\n// replaced samples are copied into *extract.\n// (false, valid): The data are left unchanged and the model\n// values are placed in *extract.\n// (true, nullptr): The data are replaced with the model, and\n// the original data samples are discarded.\n// (false, nullptr): The data is left unchanged and the model\n// is discarded (probably not what you want...).\n//\n// When extract is non-null, it needs to be the right size... this\n// should be checked by get_gap_fill_poly.\n\nvoid get_gap_fill_poly_single(const RangesInt32 &gaps, float *data,\n float *a, float *b,\n int buffer, int ncoeff,\n bool inplace, float *extract)\n{\n // Generate Ranges corresponding to samples near the edges of\n // intervals we want to fill.\n RangesInt32 rsegs = gaps.buffered((int32_t)buffer);\n rsegs.intersect(gaps.complement());\n\n // We are guaranteed that there is one or two rseg intervals\n // between each of our gaps, and zero or one rseg intervals\n // before the first gap and after the second gap.\n\n // Index of the rseg we're working with.\n int model_i = 0;\n\n for (auto const &gap: gaps.segments) {\n // std::cout << \"GAP\\n\";\n int contrib_samps = 0;\n int contrib_segs = 0;\n memset(a, 0, ncoeff*ncoeff*sizeof(*a));\n memset(b, 0, ncoeff*sizeof(*b));\n float x0 = gap.first;\n\n for (; model_i < rsegs.segments.size(); model_i++) {\n // Advance until just before this gap.\n auto const &ival = rsegs.segments[model_i];\n if (ival.second + 1 < gap.first)\n continue;\n // Include this interval in the fit.\n for (int i=ival.first; i gap.first)\n break;\n }\n\n // Restrict order based on number of contributing samples.\n int n_keep = std::min(contrib_samps / 10 + 1, ncoeff);\n if (contrib_samps > 0) {\n // Fill in a's interior.\n for (int r=1; r(ranges);\n int ndet = rangemat.size();\n\n BufferWrapper tod_buf (\"tod\", tod, false, std::vector{ndet,-1});\n int nsamp = tod_buf->shape[1];\n\n int ncoeff = order + 1; // Let us not speak of order again.\n float *a = (float*)malloc(ncoeff*(ncoeff+1)*sizeof(*a));\n float *b = a + ncoeff*ncoeff;\n\n float *ex_data = nullptr;\n std::vector ex_offsets;\n\n if (ex.ptr() != Py_None) {\n\t\t// Compute offsets of each detector into ex.\n\t\tint n = 0;\n\t\tfor (auto const &r: rangemat) {\n\t\t\tex_offsets.push_back(n);\n\t\t\tfor (auto const &r: r.segments)\n\t\t\t\tn += (r.second - r.first);\n\t\t}\n\t\tBufferWrapper ex_buf(\"ex\", ex, false, std::vector{n});\n\t\tex_data = (float*)ex_buf->buf;\n }\n\n for (int di=0; di < rangemat.size(); di++) {\n float* data = (float*)((char*)tod_buf->buf + di*tod_buf->strides[0]);\n float* _ex = ex_data;\n if (_ex != nullptr)\n\t\t\t_ex += ex_offsets[di];\n get_gap_fill_poly_single(rangemat[di], data, a, b, buffer, ncoeff,\n\t\t\t\t\t inplace, _ex);\n }\n\n free(a);\n}\n\nPYBINDINGS(\"so3g\")\n{\n\tbp::def(\"nmat_detvecs_apply\", nmat_detvecs_apply);\n\tbp::def(\"process_cuts\", process_cuts);\n\tbp::def(\"get_gap_fill_poly\", get_gap_fill_poly,\n \"get_gap_fill_poly(ranges, signal, buffer, order, extract)\\n\"\n \"\\n\"\n \"Do polynomial gap-filling.\\n\"\n \"\\n\"\n \"Args:\\n\"\n \" ranges: RangesMatrix with shape (ndet, nsamp)\\n\"\n \" signal: data array with shape (ndet, nsamp)\\n\"\n \" buffer: integer stating max number of samples to use on each end\\n\"\n \" order: order of polynomial to use (1 means linear)\\n\"\n\t\t\" inplace: whether to overwrite data array with the model\\n\"\n\t\t\" extract: array to write the original data samples (inplace)\\n\"\n\t\t\" or the model (!inplace) into.\\n\");\n}\n", "meta": {"hexsha": "d1ef4589681cce6b5dc704928eff7b02c9556431", "size": 20508, "ext": "cxx", "lang": "C++", "max_stars_repo_path": "src/array_ops.cxx", "max_stars_repo_name": "tskisner/so3g", "max_stars_repo_head_hexsha": "75c1d8dea84f862bdd2c9fa2c2f9d1c5b8da5eec", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2019-09-02T14:17:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-21T16:43:14.000Z", "max_issues_repo_path": "src/array_ops.cxx", "max_issues_repo_name": "tskisner/so3g", "max_issues_repo_head_hexsha": "75c1d8dea84f862bdd2c9fa2c2f9d1c5b8da5eec", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 70.0, "max_issues_repo_issues_event_min_datetime": "2019-05-16T23:42:40.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T14:35:35.000Z", "max_forks_repo_path": "src/array_ops.cxx", "max_forks_repo_name": "tskisner/so3g", "max_forks_repo_head_hexsha": "75c1d8dea84f862bdd2c9fa2c2f9d1c5b8da5eec", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-05-17T18:20:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-22T20:35:44.000Z", "avg_line_length": 42.4596273292, "max_line_length": 183, "alphanum_fraction": 0.5818217281, "num_tokens": 5881, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5660185498374789, "lm_q2_score": 0.5273165233795671, "lm_q1q2_score": 0.29847093386864365}} {"text": "#include \"ahrs.hpp\"\n\n/* C/C++ Includes */\n#include \n#include \n#include \n\n/* Thor Includes */\n#include \"Thor/include/thor.h\"\n#include \"Thor/include/spi.h\"\n#include \"Thor/include/gpio.h\"\n#include \"Thor/include/exceptions.h\"\n\n/* Boost Includes */\n#include \n#include \n\n/* FreeRTOS Includes */\n#include \"FreeRTOS.h\"\n#include \"task.h\"\n#include \"queue.h\"\n\n/* Project Includes */\n#include \"ahrs.hpp\"\n#include \"LSM9DS1.hpp\"\n#include \"config.hpp\"\n#include \"dataTypes.hpp\"\n#include \"threading.hpp\"\n\n/* Madgwick Filter */\n#include \"madgwick.hpp\"\n\n/* Kalman Filter */\n#include \"kalman/SquareRootUnscentedKalmanFilter.hpp\"\n#include \"IMUModel.hpp\"\n\n\n\nnamespace SOAR_AHRS\n{\n\ttypedef float T;\n\ttypedef IMU::State State;\n\ttypedef IMU::Control Control;\n\ttypedef IMU::Measurement Measurement;\n\ttypedef IMU::SystemModel SystemModel;\n\ttypedef IMU::MeasurementModel MeasurementModel;\n\n\tconst int updateRate_mS = (1.0 / SENSOR_UPDATE_FREQ_HZ) * 1000.0;\n\tconst int magMaxUpdateRate_mS = (1.0 / LSM9DS1_M_MAX_BW) * 1000.0;\n\n\tconst float accelUncertainty = 0.8f;\n\tconst float gyroUncertainty = 1.05f;\n\n\tvoid ahrsTask(void* argument)\n\t{\n\t\t#ifdef DEBUG\n\t\tvolatile float pitch;\n\t\tvolatile float roll;\n\t\tvolatile float yaw;\n\t\tvolatile float ax;\n\t\tvolatile float ay;\n\t\tvolatile float az;\n\t\tvolatile float gx;\n\t\tvolatile float gy;\n\t\tvolatile float gz;\n\t\tvolatile float mx;\n\t\tvolatile float my;\n\t\tvolatile float mz;\n\t\tvolatile UBaseType_t stackHighWaterMark_AHRS = 0;\n\t\tvolatile size_t bytesRemaining = xPortGetFreeHeapSize();\n\t\t#endif\n\n\t\tAHRSData_t ahrsData;\t\t\t\t\t/* Output struct to push to the motor controller thread */\n\n\n\t\t/*----------------------------------\n\t\t* Initialize the UKF\n\t\t*----------------------------------*/\n\t\tState x, x_ukf;\n\t\tControl u;\n\t\tSystemModel sys;\n\t\tMeasurementModel om;\n\t\tMeasurement meas;\n\n\t\tEigen::Matrix R;\n\t\tEigen::Matrix processNoise;\n\n\t\tKalman::SquareRootUnscentedKalmanFilter ukf(0.5f, 3.0f, 0.0f);\n\n\t\tx.setZero();\n\t\tu.setZero();\n\t\tR.setZero();\n\n\t\tT cnst = 5.00e-4f;\n\t\tT dnst = 3.33e-4f;\n\t\tT enst = 5.00e-4f;\n\n\t\tprocessNoise <<\n\t\t\tcnst, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,\n\t\t\t0.0f, dnst, 0.0f, 0.0f, 0.0f, 0.0f,\n\t\t\t0.0f, 0.0f, enst, 0.0f, 0.0f, 0.0f,\n\t\t\t0.0f, 0.0f, 0.0f, cnst, 0.0f, 0.0f,\n\t\t\t0.0f, 0.0f, 0.0f, 0.0f, dnst, 0.0f,\n\t\t\t0.0f, 0.0f, 0.0f, 0.0f, 0.0f, enst;\n\n\t\tsys.setCovariance(processNoise);\n\n\t\tR(0, 0) = accelUncertainty * accelUncertainty;\n\t\tR(1, 1) = accelUncertainty * accelUncertainty;\n\t\tR(2, 2) = accelUncertainty * accelUncertainty;\n\t\tR(3, 3) = gyroUncertainty * gyroUncertainty;\n\t\tR(4, 4) = gyroUncertainty * gyroUncertainty;\n\t\tR(5, 5) = gyroUncertainty * gyroUncertainty;\n\n\t\tom.setCovariance(R);\n\n\t\tukf.init(x);\n\n\n\t\t/*----------------------------------\n\t\t* Initialize the IMU\n\t\t*----------------------------------*/\n\t\tGPIOClass_sPtr lsm_ss_xg = boost::make_shared(GPIOC, PIN_4, ULTRA_SPD, NOALTERNATE);\n\t\tGPIOClass_sPtr lsm_ss_m = boost::make_shared(GPIOC, PIN_3, ULTRA_SPD, NOALTERNATE);\n\t\tSPIClass_sPtr lsm_spi = spi2;\n\n\t\tLSM9DS1 imu(lsm_spi, lsm_ss_xg, lsm_ss_m);\n\n\t\t/* Force halt of the device if the IMU cannot be reached */\n\t\tif (imu.begin() == 0)\n\t\t\tBasicErrorHandler(\"The IMU WHO_AM_I registers did not return valid readings\");\n\n\t\t//TODO: Switch this out to print over the serial port\n\n\t\timu.calibrate(true); /* \"true\" forces an automatic software subtraction of the calculated bias from all further data */\n\t\timu.calibrateMag(true); /* \"true\" writes the offest into the mag sensor hardware for automatic subtraction in results */\n\n\t\tint count = 0;\n\n\n\t\t/*----------------------------------\n\t\t* Initialize the Madgwick Filter\n\t\t*----------------------------------*/\n\t\tfloat beta = 10.0;\n\t\tEigen::Vector3f accel_raw, gyro_raw, mag_raw;\n\t\tEigen::Vector3f accel_filtered, gyro_filtered, mag_filtered, eulerDeg;\n\n\t\tMadgwickFilter ahrs((AHRS_UPDATE_RATE_MULTIPLIER * SENSOR_UPDATE_FREQ_HZ), beta);\n\n\t\tfloat dt = (1.0f / SENSOR_UPDATE_FREQ_HZ);\n\t\tfloat tau_accel = 0.01f;\n\t\tfloat alpha_lp_accel = dt / tau_accel;\n\n\n\t\t/* Tell init task that this thread's initialization is done and ok to run.\n\t\t* Wait for init task to resume operation. */\n\t\txTaskSendMessage(INIT_TASK, 1u);\n\t\tvTaskSuspend(NULL);\n\t\ttaskYIELD();\n\n\n\t\tTickType_t lastTimeWoken = xTaskGetTickCount();\n\t\tfor (;;)\n\t\t{\n\t\t\t#ifdef DEBUG\n\t\t\tstackHighWaterMark_AHRS = uxTaskGetStackHighWaterMark(NULL);\n\t\t\tbytesRemaining = xPortGetFreeHeapSize();\n\t\t\t#endif\n\n\t\t\t/*----------------------------\n\t\t\t* Sensor Reading\n\t\t\t*---------------------------*/\n\t\t\t/* Update Accel & Gyro Data at whatever frequency set by user. Max bandwidth on\n\t\t\t* chip is 952Hz which will saturate FreeRTOS if sampled that often.*/\n\t\t\t//taskENTER_CRITICAL();\n\t\t\timu.readAccel();\n\t\t\timu.readGyro();\n\t\t\t\n\n\t\t\t/* Update Mag Data at a max frequency set by LSM9DS1_M_MAX_BW (~75Hz) */\n\t\t\t#if (SENSOR_UPDATE_FREQ_HZ > LSM9DS1_M_MAX_BW)\n\t\t\tif (count > magMaxUpdateRate_mS)\n\t\t\t{\n\t\t\t\timu.readMag();\n\t\t\t\timu.calcMag();\n\t\t\t\tcount = 0;\n\t\t\t}\n\t\t\telse\n\t\t\t\tcount += updateRate_mS;\n\t\t\t#else\n\t\t\timu.readMag();\n\t\t\timu.calcMag();\n\t\t\t#endif\n\t\t\t//taskEXIT_CRITICAL();\n\n\t\t\t/* Convert raw data from chip into meaningful data */\n\t\t\timu.calcAccel(); imu.calcGyro();\n\n// \t\t\t#ifdef DEBUG\n// \t\t\tax = imu.aRaw[0];\n// \t\t\tay = imu.aRaw[1];\n// \t\t\taz = imu.aRaw[2];\n// \n// \t\t\tgx = imu.gRaw[0];\n// \t\t\tgy = imu.gRaw[1];\n// \t\t\tgz = imu.gRaw[2];\n// \n// \t\t\tmx = imu.mRaw[0];\n// \t\t\tmy = imu.mRaw[1];\n// \t\t\tmz = imu.mRaw[2];\n// \t\t\t#endif\n\n\t\t\taccel_raw << imu.aRaw[0], imu.aRaw[1], imu.aRaw[2];\n\t\t\tgyro_raw << imu.gRaw[0], imu.gRaw[1], imu.gRaw[2];\n\t\t\tmag_raw <<\n\t\t\t\t-imu.mRaw[0], //Align mag x with accel x\n\t\t\t\t-imu.mRaw[1], //Align mag y with accel y\n\t\t\t\t-imu.mRaw[2]; //from LSM9DS1, mag z is opposite direction of accel z\n\n\n\t\t\t/*----------------------------\n\t\t\t* UKF Algorithm\n\t\t\t*---------------------------*/\n\t\t\t//Simulate the system\n\t\t\tx = sys.f(x, u);\n\n\t\t\t//Predict state for current time step \n\t\t\tx_ukf = ukf.predict(sys);\n\n\t\t\t//Take a measurement given system state\n\t\t\tmeas << accel_raw, gyro_raw;\n\n\t\t\t//Update the state equation given measurement\n\t\t\tx_ukf = ukf.update(om, meas);\n\n\n\t\t\taccel_filtered << x_ukf.ax(), x_ukf.ay(), x_ukf.az();\n\t\t\tgyro_filtered << x_ukf.gx(), x_ukf.gy(), x_ukf.gz();\n\t\t\tmag_filtered = mag_raw;\n\n\n\t\t\t/*----------------------------\n\t\t\t* AHRS Algorithm\n\t\t\t*---------------------------*/\n\t\t\t/* The Madgwick filter needs to run between 3-5 times as fast IMU measurements\n\t\t\t* to achieve decent convergence to a stable value. This thread only runs when\n\t\t\t* new data has arrived from the IMU, so frequency multiplication is as simple\n\t\t\t* as looping 3-5 times here. */\n\t\t\tfor (int i = 0; i < AHRS_UPDATE_RATE_MULTIPLIER; i++)\n\t\t\t\tahrs.update(accel_filtered, gyro_filtered, mag_filtered);\n\n\t\t\tahrs.getEulerDeg(eulerDeg);\n\t\t\tahrsData(eulerDeg, accel_filtered, gyro_filtered, mag_filtered);\n\n\t\t\t#ifdef DEBUG\n\t\t\tpitch = eulerDeg(0);\n\t\t\troll = eulerDeg(1);\n\t\t\tyaw = eulerDeg(2);\n\n\t\t\tax = accel_filtered(0);\n\t\t\tay = accel_filtered(1);\n\t\t\taz = accel_filtered(2);\n\n\t\t\tgx = gyro_filtered(0);\n\t\t\tgy = gyro_filtered(1);\n\t\t\tgz = gyro_filtered(2);\n\n\t\t\tmx = mag_filtered(0);\n\t\t\tmy = mag_filtered(1);\n\t\t\tmz = mag_filtered(2);\n\t\t\t#endif\n\n\t\t\t/* Send data over to the Serial thread*/\n\t\t\tif (xSemaphoreTake(ahrsBufferMutex, 0) == pdPASS)\n\t\t\t{\n\t\t\t\txQueueOverwrite(qAHRS, &ahrsData);\n\t\t\t\txSemaphoreGive(ahrsBufferMutex);\n\t\t\t}\n\n\t\t\tvTaskDelayUntil(&lastTimeWoken, pdMS_TO_TICKS(updateRate_mS));\n\t\t}\n\t}\n}\n\n", "meta": {"hexsha": "803d1a0cf6fb5cb0b774bdaca94403637d509a8c", "size": 7453, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ahrs.cpp", "max_stars_repo_name": "brandonbraun653/TeamSOAR", "max_stars_repo_head_hexsha": "472c7e900de20545476e76395ebe89ab5467ae11", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ahrs.cpp", "max_issues_repo_name": "brandonbraun653/TeamSOAR", "max_issues_repo_head_hexsha": "472c7e900de20545476e76395ebe89ab5467ae11", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ahrs.cpp", "max_forks_repo_name": "brandonbraun653/TeamSOAR", "max_forks_repo_head_hexsha": "472c7e900de20545476e76395ebe89ab5467ae11", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.150877193, "max_line_length": 122, "alphanum_fraction": 0.6390715148, "num_tokens": 2402, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.658417500561683, "lm_q2_score": 0.4532618480153861, "lm_q1q2_score": 0.29843553307025994}} {"text": "//\n// Created by dchansen on 10/12/18.\n//\n#include \"ConvolutionMatrix.h\"\n\n#include \n#include \n#include \"vector_td_utilities.h\"\n#include \n\nnamespace\n{\n using namespace Gadgetron;\n\n template\n struct iteration_counter { };\n\n template class K>\n void iterate_body(\n const vector_td &point,\n const vector_td &matrix_size,\n std::vector &indices,\n std::vector &weights,\n vector_td &image_point,\n size_t index,\n const ConvolutionKernel& kernel,\n iteration_counter<-1>)\n {\n auto delta = abs(image_point - point);\n indices.push_back(index);\n weights.push_back(kernel.get(delta));\n }\n\n template class K, int N>\n void iterate_body(\n const vector_td &point,\n const vector_td &matrix_size,\n std::vector &indices,\n std::vector &weights,\n vector_td &image_point,\n size_t index,\n const ConvolutionKernel& kernel,\n iteration_counter)\n {\n size_t frame_offset = std::accumulate(&matrix_size[0], &matrix_size[N], 1, std::multiplies());\n\n for (int i = std::ceil(point[N] - kernel.get_radius());\n i <= std::floor(point[N] + kernel.get_radius());\n i++)\n {\n auto wrapped_i = (i + matrix_size[N]) % matrix_size[N];\n size_t index2 = index + frame_offset * wrapped_i;\n image_point[N] = i;\n iterate_body(point, matrix_size, indices, weights, image_point,\n index2, kernel, iteration_counter());\n }\n }\n\n template class K>\n std::tuple, std::vector> get_indices(\n const vector_td &point,\n const vector_td &matrix_size,\n const ConvolutionKernel& kernel)\n {\n std::vector indices;\n indices.reserve(size_t(std::pow(std::ceil(kernel.get_width()), D)));\n\n std::vector weights;\n weights.reserve(size_t(std::pow(std::ceil(kernel.get_width()), D)));\n\n vector_td image_point;\n size_t index = 0;\n iterate_body(point, matrix_size, indices, weights, image_point, index,\n kernel, iteration_counter());\n\n return std::make_tuple(std::move(indices), std::move(weights));\n }\n}\n\n\ntemplate class K>\nGadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel)\n{\n ConvolutionMatrix matrix(trajectory.get_number_of_elements(),\n prod(matrix_size));\n \n #pragma omp parallel for \n for (int i = 0; i < (int)trajectory.get_number_of_elements(); i++)\n {\n std::tie(matrix.indices[i], matrix.weights[i]) = get_indices(\n trajectory[i], matrix_size, kernel);\n }\n\n return matrix;\n}\n\n\ntemplate\nGadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::transpose(const Gadgetron::ConvInternal::ConvolutionMatrix &matrix) {\n\n auto work_index = boost::irange(size_t(0),matrix.n_cols);\n\n ConvolutionMatrix transposed(matrix.n_rows, matrix.n_cols);\n\n std::vector counts(matrix.n_rows, 0);\n\n for (size_t i : work_index)\n {\n auto &rows = matrix.indices[i];\n for (auto &row : rows)\n counts[row]++;\n }\n\n for (size_t i = 0; i < counts.size(); i++)\n {\n transposed.indices[i].reserve(counts[i]);\n transposed.weights[i].reserve(counts[i]);\n }\n\n for (size_t i : work_index )\n {\n auto &rows = matrix.indices[i];\n auto &weights = matrix.weights[i];\n for (size_t n = 0; n < rows.size(); n++)\n {\n transposed.indices[rows[n]].push_back(i);\n transposed.weights[rows[n]].push_back(weights[n]);\n }\n }\n\n return transposed;\n}\n\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::make_conv_matrix(\n const Gadgetron::hoNDArray> trajectory,\n const Gadgetron::vector_td &matrix_size,\n const ConvolutionKernel& kernel);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::transpose(\n const Gadgetron::ConvInternal::ConvolutionMatrix &matrix);\n\ntemplate Gadgetron::ConvInternal::ConvolutionMatrix\nGadgetron::ConvInternal::transpose(\n const Gadgetron::ConvInternal::ConvolutionMatrix &matrix);\n\n", "meta": {"hexsha": "c26444862786fc1d3cc19ecbb9bd16698042e7c3", "size": 10216, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "toolboxes/nfft/cpu/ConvolutionMatrix.cpp", "max_stars_repo_name": "roopchansinghv/gadgetron", "max_stars_repo_head_hexsha": "fb6c56b643911152c27834a754a7b6ee2dd912da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-02-22T21:06:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T21:06:36.000Z", "max_issues_repo_path": "toolboxes/nfft/cpu/ConvolutionMatrix.cpp", "max_issues_repo_name": "apd47/gadgetron", "max_issues_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "toolboxes/nfft/cpu/ConvolutionMatrix.cpp", "max_forks_repo_name": "apd47/gadgetron", "max_forks_repo_head_hexsha": "073e84dabe77d2dae3b3dd9aa4bf9edbf1f890f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.868852459, "max_line_length": 110, "alphanum_fraction": 0.7128034456, "num_tokens": 2695, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.658417500561683, "lm_q2_score": 0.4532618480153861, "lm_q1q2_score": 0.29843553307025994}} {"text": "#include \"hoCuNDArray_utils.h\"\n#include \"radial_utilities.h\"\n#include \"cuNDArray_fileio.h\"\n#include \"cuNDArray_math.h\"\n#include \"imageOperator.h\"\n#include \"identityOperator.h\"\n#include \"hoPartialDerivativeOperator.h\"\n#include \"hoCuConebeamProjectionOperator.h\"\n#include \"cuConvolutionOperator.h\"\n#include \"hoCuNDArray_blas.h\"\n#include \"hoCuNDArray_elemwise.h\"\n#include \"hoCuNDArray_blas.h\"\n#include \"cgSolver.h\"\n#include \"CBCT_acquisition.h\"\n#include \"complext.h\"\n#include \"encodingOperatorContainer.h\"\n#include \"vector_td_io.h\"\n#include \"hoPartialDerivativeOperator.h\"\n#include \"hoCuGPBBSolver.h\"\n#include \"hoCuTvOperator.h\"\n#include \"hoCuTvPicsOperator.h\"\n#include \"hoCuNCGSolver.h\"\n#include \"hoCuCgDescentSolver.h\"\n#include \"hoNDArray_utils.h\"\n#include \"hoCuPartialDerivativeOperator.h\"\n#include \"cuTvOperator.h\"\n#include \"cuTv1dOperator.h\"\n#include \"cuTvPicsOperator.h\"\n#include \"CBSubsetOperator.h\"\n#include \"osSPSSolver.h\"\n#include \"osMOMSolver.h\"\n#include \"osMOMSolverD.h\"\n#include \"osMOMSolverD2.h\"\n#include \"hoCuNCGSolver.h\"\n#include \"osMOMSolverD3.h\"\n#include \"osMOMSolverL1.h\"\n#include \"osMOMSolverF.h\"\n#include \"osAHZCSolver.h\"\n#include \"ADMMSolver.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"cuSolverUtils.h\"\n#include \"osPDsolver.h\"\n#include \"osLALMSolver.h\"\n#include \"osLALMSolver2.h\"\n#include \"cuATrousOperator.h\"\n#include \"hdf5_utils.h\"\n#include \"cuEdgeATrousOperator.h\"\n#include \"cuDCTOperator.h\"\n#include \"cuDCTDerivativeOperator.h\"\n#include \"dicomWriter.h\"\n#include \"conebeam_projection.h\"\n#include \"weightingOperator.h\"\n#include \"hoNDArray_math.h\"\n#include \"cuNCGSolver.h\"\n#include \"CT_acquisition.h\"\n#include \"hoCuOSOMSolver.h\"\n\nusing namespace std;\nusing namespace Gadgetron;\n\nnamespace po = boost::program_options;\n\n\nboost::shared_ptr > calculate_prior(boost::shared_ptr binning,boost::shared_ptr ps, hoCuNDArray& projections, std::vector is_dims, floatd3 imageDimensions){\n\tstd::cout << \"Calculating FDK prior\" << std::endl;\n\tboost::shared_ptr binning_pics=binning->get_3d_binning();\n\tstd::vector is_dims3d = is_dims;\n\tis_dims3d.pop_back();\n\tboost::shared_ptr< hoCuConebeamProjectionOperator >\n\tEp( new hoCuConebeamProjectionOperator() );\n\tEp->setup(ps,binning_pics,imageDimensions);\n\tEp->set_codomain_dimensions(ps->get_projections()->get_dimensions().get());\n\tEp->set_domain_dimensions(&is_dims3d);\n\tEp->set_use_filtered_backprojection(true);\n\tboost::shared_ptr > prior3d(new hoCuNDArray(&is_dims3d));\n\tEp->mult_MH(&projections,prior3d.get());\n\n\thoCuNDArray tmp_proj(*ps->get_projections());\n\tEp->mult_M(prior3d.get(),&tmp_proj);\n\tfloat s = dot(ps->get_projections().get(),&tmp_proj)/dot(&tmp_proj,&tmp_proj);\n\t*prior3d *= s;\n\tboost::shared_ptr > prior(new cuNDArray(*expand( prior3d.get(), is_dims.back() )));\n\tstd::cout << \"Prior complete\" << std::endl;\n\treturn prior;\n}\n\n\nboost::shared_ptr> calculate_weightImage(boost::shared_ptr binning,boost::shared_ptr ps, hoCuNDArray& ho_projections, std::vector is_dims, floatd3 imageDimensions){\n\n\tcuNDArray projections(ho_projections);\n\tboost::shared_ptr binning_pics=binning->get_3d_binning();\n\tstd::vector is_dims3d = is_dims;\n\tis_dims3d.pop_back();\n\tauto Ep = boost::make_shared();\n\tauto ps2 = boost::make_shared(boost::shared_ptr>(),ps->get_geometry());\n\tEp->setup(ps2,binning_pics,imageDimensions);\n\tEp->set_codomain_dimensions(ps->get_projections()->get_dimensions().get());\n\tEp->set_domain_dimensions(&is_dims3d);\n\t//Ep->set_use_filtered_backprojection(true);\n\tEp->offset_correct(&projections);\n\t//Ep->mult_MH(&projections,prior3d.get());\n\t//cgSolver> solv;\n\tcuNCGSolver solv;\n\tsolv.set_non_negativity_constraint(true);\n\tsolv.set_encoding_operator(Ep);\n\tsolv.set_max_iterations(10);\n\tauto prior3d = solv.solve(&projections);\n\t//auto prior3d = boost::make_shared>(is_dims3d);\n\twrite_nd_array(prior3d.get(),\"fdk.real\");\n\tcuNDArray tmp_proj(projections);\n\tclear(&tmp_proj);\n\tEp->mult_M(prior3d.get(),&tmp_proj);\n\t//float s = dot(ps->get_projections().get(),&tmp_proj)/dot(&tmp_proj,&tmp_proj);\n\t//std::cout << \"Scaling \" << s << std::endl;\n/*\n\t //Ep->offset_correct(&tmp_proj);\n\t//tmp_proj *= s;\n\twrite_nd_array(&tmp_proj,\"projtmp.real\");\n\ttmp_proj -= projections;\n\ttmp_proj *= float(-1);\n\tabs_inplace(&tmp_proj);\n\n\twrite_nd_array(ps->get_projections().get(),\"proj.real\");\n\twrite_nd_array(&tmp_proj,\"projdiff.real\");\n\tstd::cout << \"Proj size \";\n\tauto pdims = *tmp_proj.get_dimensions();\n\tfor (auto p : pdims ) std::cout << p << \" \";\n\tstd::cout << std::endl;\n\t//Ep->set_use_filtered_backprojection(false);\n\t//Ep->mult_MH(&tmp_proj,prior3d.get());\n\t//solv.set_non_negativity_constraint(false);\n\tprior3d = solv.solve(&tmp_proj);\n\t//abs_inplace(prior.get());\n\tstd::cout << \"Prior complete\" << std::endl;\n\t*/\n\treturn prior3d;\n}\n\n\nint main(int argc, char** argv)\n{\n\n\tstring acquisition_filename;\n\tstring outputFile;\n\tuintd3 imageSize;\n\tfloatd3 voxelSize;\n\tint device;\n\tunsigned int downsamples;\n\tunsigned int iterations;\n\tunsigned int subsets;\n\tfloat rho,tau;\n\tfloat tv_weight,pics_weight, wavelet_weight,huber,sigma,dct_weight;\n\tfloat tv_4d;\n bool use_non_negativity;\n\tint reg_iter;\n\n\tpo::options_description desc(\"Allowed options\");\n\n\tdesc.add_options()\n \t\t\t\t(\"help\", \"produce help message\")\n \t\t\t\t(\"acquisition,a\", po::value(&acquisition_filename)->default_value(\"acquisition.hdf5\"), \"Acquisition data\")\n \t\t\t\t(\"samples,n\",po::value(),\"Number of samples per ray\")\n \t\t\t\t(\"output,f\", po::value(&outputFile)->default_value(\"reconstruction.hdf5\"), \"Output filename\")\n \t\t\t\t(\"size,s\",po::value(&imageSize)->default_value(uintd3(512,512,1)),\"Image size in pixels\")\n \t\t\t\t(\"binning,b\",po::value(),\"Binning file for 4d reconstruction\")\n \t\t\t\t(\"SAG\",\"Use exact SAG correction if present\")\n \t\t\t\t(\"voxelSize,v\",po::value(&voxelSize)->default_value(floatd3(0.488f,0.488f,1.0f)),\"Voxel size in mm\")\n \t\t\t\t(\"dimensions,d\",po::value(),\"Image dimensions in mm. Overwrites voxelSize.\")\n \t\t\t\t(\"iterations,i\",po::value(&iterations)->default_value(10),\"Number of iterations\")\n \t\t\t\t(\"device\",po::value(&device)->default_value(0),\"Number of the device to use (0 indexed)\")\n \t\t\t\t(\"downsample,D\",po::value(&downsamples)->default_value(0),\"Downsample projections this factor\")\n \t\t\t\t(\"subsets,u\",po::value(&subsets)->default_value(10),\"Number of subsets to use\")\n \t\t\t\t(\"TV\",po::value(&tv_weight)->default_value(0),\"Total variation weight in spatial dimensions\")\n\t\t\t\t\t\t\t(\"TV4D\",po::value(&tv_4d)->default_value(0),\"Total variation weight in temporal dimensions\")\n \t\t\t\t(\"PICS\",po::value(&pics_weight)->default_value(0),\"PICS weight\")\n \t\t\t\t(\"Wavelet,W\",po::value(&wavelet_weight)->default_value(0),\"Weight of the wavelet operator\")\n \t\t\t\t(\"Huber\",po::value(&huber)->default_value(0),\"Huber weight\")\n \t\t\t\t(\"use_prior\",\"Use an FDK prior\")\n \t\t\t\t(\"use_non_negativity\",po::value(&use_non_negativity)->default_value(true),\"Prevent image from having negative attenuation\")\n \t\t\t\t(\"sigma\",po::value(&sigma)->default_value(0.1),\"Sigma for billateral filter\")\n \t\t\t\t(\"DCT\",po::value(&dct_weight)->default_value(0),\"DCT regularization\")\n \t\t\t\t(\"3D\",\"Only use binning for selecting valid projections\")\n\t\t\t\t\t\t\t(\"tau\",po::value(&tau)->default_value(1e-5),\"Tau value for solver\")\n\t\t\t\t\t\t\t(\"reg_iter\",po::value(®_iter)->default_value(2))\n \t\t\t\t;\n\n\tpo::variables_map vm;\n\tpo::store(po::parse_command_line(argc, argv, desc), vm);\n\tpo::notify(vm);\n\n\tif (vm.count(\"help\")) {\n\t\tcout << desc << \"\\n\";\n\t\treturn 1;\n\t}\n\n\tstd::stringstream command_line_string;\n\tstd::cout << \"Command line options:\" << std::endl;\n\tfor (po::variables_map::iterator it = vm.begin(); it != vm.end(); ++it){\n\t\tboost::any a = it->second.value();\n\t\tcommand_line_string << it->first << \": \";\n\t\tif (a.type() == typeid(std::string)) command_line_string << it->second.as();\n\t\telse if (a.type() == typeid(int)) command_line_string << it->second.as();\n\t\telse if (a.type() == typeid(unsigned int)) command_line_string << it->second.as();\n\t\telse if (a.type() == typeid(float)) command_line_string << it->second.as();\n\t\telse if (a.type() == typeid(vector_td)) command_line_string << it->second.as >();\n\t\telse if (a.type() == typeid(vector_td)) command_line_string << it->second.as >();\n\t\telse if (a.type() == typeid(vector_td)) command_line_string << it->second.as >();\n else if (a.type() == typeid(bool)) command_line_string << it->second.as();\n\t\telse command_line_string << \"Unknown type\" << std::endl;\n\t\tcommand_line_string << std::endl;\n\t}\n\tstd::cout << command_line_string.str();\n\n\tcudaSetDevice(device);\n\tcudaDeviceReset();\n\n\t//Really weird stuff. Needed to initialize the device?? Should find real bug.\n\tcudaDeviceManager::Instance()->lockHandle();\n\tcudaDeviceManager::Instance()->unlockHandle();\n\n\tboost::shared_ptr ps(new CBCT_acquisition());\n\tps->load(acquisition_filename);\n\tps->get_geometry()->print(std::cout);\n\tps->downsample(downsamples);\n\n\tfloat SDD = ps->get_geometry()->get_SDD();\n\tfloat SAD = ps->get_geometry()->get_SAD();\n\n\tboost::shared_ptr binning(new CBCT_binning());\n\tif (vm.count(\"binning\")){\n\t\tstd::cout << \"Loading binning data\" << std::endl;\n\t\tbinning->load(vm[\"binning\"].as());\n\t\tif (vm.count(\"3D\"))\n\t\t\tbinning = binning->get_3d_binning();\n\t} else binning->set_as_default_3d_bin(ps->get_projections()->get_size(2));\n\tbinning->print(std::cout);\n\n\tfloatd3 imageDimensions;\n\tif (vm.count(\"dimensions\")){\n\t\timageDimensions = vm[\"dimensions\"].as();\n\t\tvoxelSize = imageDimensions/imageSize;\n\t}\n\telse imageDimensions = voxelSize*imageSize;\n\n\tfloat lengthOfRay_in_mm = norm(imageDimensions);\n\tunsigned int numSamplesPerPixel = 3;\n\tfloat minSpacing = min(voxelSize)/numSamplesPerPixel;\n\n\tunsigned int numSamplesPerRay;\n\tif (vm.count(\"samples\")) numSamplesPerRay = vm[\"samples\"].as();\n\telse numSamplesPerRay = ceil( lengthOfRay_in_mm / minSpacing );\n\n\tfloat step_size_in_mm = lengthOfRay_in_mm / numSamplesPerRay;\n\tsize_t numProjs = ps->get_projections()->get_size(2);\n\tsize_t needed_bytes = 2 * prod(imageSize) * sizeof(float);\n\tstd::vector is_dims = to_std_vector((uint64d3)imageSize);\n\n\tstd::cout << \"IS dimensions \" << is_dims[0] << \" \" << is_dims[1] << \" \" << is_dims[2] << std::endl;\n\tstd::cout << \"Image size \" << imageDimensions << std::endl;\n\n\tis_dims.push_back(binning->get_number_of_bins());\n\n\t//osLALMSolver> solver;\n\thoCuOSMOMSolver solver;\n\t//osMOMSolverL1> solver;\n\t//osAHZCSolver> solver;\n\t//osMOMSolverF> solver;\n\t//ADMMSolver> solver;\n\tsolver.set_dump(false);\n\n\n\n\n\t//hoCuCgDescentSolver solver;\n\n\t//osSPSSolver> solver;\n\t//hoCuNCGSolver solver;\n\t//solver.set_domain_dimensions(&is_dims);\n\tsolver.set_max_iterations(iterations);\n\tsolver.set_output_mode(osSPSSolver>::OUTPUT_VERBOSE);\n\tsolver.set_tau(tau);\n\tsolver.set_non_negativity_constraint(use_non_negativity);\n\tsolver.set_huber(huber);\n\tsolver.set_reg_steps(reg_iter);\n\t//solver.set_rho(rho);\n\n if (tv_weight > 0){\n\n \tauto Dx = boost::make_shared>(0);\n \tDx->set_weight(tv_weight);\n \tDx->set_domain_dimensions(&is_dims);\n \tDx->set_codomain_dimensions(&is_dims);\n\n \tauto Dy = boost::make_shared>(1);\n \tDy->set_weight(tv_weight);\n \tDy->set_domain_dimensions(&is_dims);\n \tDy->set_codomain_dimensions(&is_dims);\n\n\n \tauto Dz = boost::make_shared>(2);\n \tDz->set_weight(tv_weight);\n \tDz->set_domain_dimensions(&is_dims);\n \tDz->set_codomain_dimensions(&is_dims);\n\n \tsolver.add_regularization_group({Dx,Dy,Dz});\n if (tv_4d > 0) {\n auto Dt = boost::make_shared>(3);\n Dt->set_weight(tv_4d);\n Dt->set_domain_dimensions(&is_dims);\n Dt->set_codomain_dimensions(&is_dims);\n solver.add_regularization_operator(Dt);\n }\n/*\n\tauto projections = *ps->get_projections();\n \tauto prior_weight = calculate_weightImage(binning,ps,projections,is_dims,imageDimensions);\n \t//sqrt_inplace(prior_weight.get());\n \tstd::cout << \"Prior min \" << min(prior_weight.get()) << std::endl;\n \t//*prior_weight -= min(prior_weight.get());\n \t*prior_weight /= asum(prior_weight.get())/prior_weight->get_number_of_elements();\n \t*prior_weight -= max(prior_weight.get());\n \t*prior_weight *= float(-1);\n \t//clamp_min(prior_weight.get(),float(1e-2));\n \t//reciprocal_inplace(prior_weight.get());\n\n\n \twrite_nd_array(prior_weight.get(),\"prior.real\");\n \t//cudaDeviceReset();\n \tauto Wt = boost::make_shared>>(prior_weight,Dt);\n\tWt->set_weight(tv_weight);\n \tWt->set_domain_dimensions(&is_dims);\n \tWt->set_codomain_dimensions(&is_dims);\n*/\n \t//lver.add_regularization_operator(Dt);\n\n\n\n\n }\n /*\n if (pics_weight > 0){\n\n \tauto Dx = boost::make_shared>(0);\n \tDx->set_weight(pics_weight);\n \tDx->set_domain_dimensions(&is_dims);\n \tDx->set_codomain_dimensions(&is_dims);\n\n \tauto Dy = boost::make_shared>(1);\n \tDy->set_weight(pics_weight);\n \tDy->set_domain_dimensions(&is_dims);\n \tDy->set_codomain_dimensions(&is_dims);\n\n\n \tauto Dz = boost::make_shared>(2);\n \tDz->set_weight(pics_weight);\n \tDz->set_domain_dimensions(&is_dims);\n \tDz->set_codomain_dimensions(&is_dims);\n\n \tsolver.add_regularization_group({Dx,Dy,Dz},prior);\n\n\n }*/\n\n/*\n\tif (tv_weight > 0){\n\n\t\tauto Dx = boost::make_shared>(0);\n\t\tDx->set_weight(tv_weight);\n\t\tDx->set_domain_dimensions(&is_dims);\n\t\tDx->set_codomain_dimensions(&is_dims);\n\n\t\tauto Dy = boost::make_shared>(1);\n\t\tDy->set_weight(tv_weight);\n\t\tDy->set_domain_dimensions(&is_dims);\n\t\tDy->set_codomain_dimensions(&is_dims);\n\n\n\t\tauto Dz = boost::make_shared>(2);\n\t\tDz->set_weight(tv_weight);\n\t\tDz->set_domain_dimensions(&is_dims);\n\t\tDz->set_codomain_dimensions(&is_dims);\n\n\n\n\t\tsolver.add_regularization_group({Dx,Dy,Dz});\n\n\n\t}\n\n*/\n\n\tif (dct_weight > 0){\n\t\tauto dctOp = boost::make_shared>();\n\t\tdctOp->set_domain_dimensions(&is_dims);\n\t\tdctOp->set_weight(dct_weight);\n\t\tsolver.add_regularization_operator(dctOp);\n\t}\n\n\tauto E = boost::make_shared >(subsets);\n\n\n\t//E->setup(ps,binning,imageDimensions);\n\tE->setup(ps,binning,imageDimensions);\n\tE->set_domain_dimensions(&is_dims);\n\tE->set_codomain_dimensions(ps->get_projections()->get_dimensions().get());\n\n\tsolver.set_encoding_operator(E);\n\n\n\n\t//auto projections = boost::make_shared>(*ps->get_projections());\n\thoCuNDArray projections = *ps->get_projections();\n\tps->set_projections(boost::shared_ptr>());\n\tstd::cout << \"Projection norm:\" << nrm2(&projections) << std::endl;\n\t//E->set_use_offset_correction(false);\n\n\t//boost::shared_ptr> mask;\n\t//mask = E->calculate_mask(projections,0.03f);\n\t//ps->set_projections(boost::shared_ptr>()); //Clear projections from host memory.\n\t{\n\t\tauto cu_proj = cuNDArray(projections);\n\t\tE->offset_correct(&cu_proj);\n\t\tcu_proj.to_host(&projections);\n\t}\n\t//E->set_mask(mask);\n\tstd::cout << \"Projection norm:\" << nrm2(&projections) << std::endl;\n\n\n\n\t//solver.set_damping(1e-6);\n\n\t/*\n boost::shared_ptr > prior;\n\n if (vm.count(\"use_prior\")) {\n \tprior = calculate_prior(binning,ps,projections,is_dims,imageDimensions);\n \tsolver.set_x0(prior);\n }\n\t */\n\tboost::shared_ptr> result;\n\t{\n\t\tGPUTimer tim(\"Solver\");\n\t\tresult = solver.solve(&projections);\n\t}\n//\tglobal_timer.reset();\n\tstd::cout << \"Penguin\" << nrm2(result.get()) << std::endl;\n\n\tstd::cout << \"Result sum \" << asum(result.get()) << std::endl;\n\n\t//apply_mask(result.get(),mask.get());\n\n\tstd::cout << \"Result sum \" << asum(result.get()) << std::endl;\n\t//saveNDArray2HDF5(result.get(),outputFile,imageDimensions,vector_td(0),command_line_string.str(),iterations);\n\n\n\n\tsaveNDArray2HDF5(result.get(),outputFile,imageDimensions,floatd3(0,0,0),command_line_string.str(),iterations);\n//\twrite_nd_array(result.get(),\"reconstruction.real\");\n\t//write_dicom(result.get(),command_line_string.str(),imageDimensions);\n\n\n\n}\n", "meta": {"hexsha": "4829388544f38e2c7a3474892803a53467dc6b66", "size": 17036, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "xray/hoCuCBOS_reconstruct.cpp", "max_stars_repo_name": "ahsanjav/gt-tomography", "max_stars_repo_head_hexsha": "1f53d72672ccda417bc8966d8497af6d786e8935", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2017-06-26T13:41:55.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-10T11:06:27.000Z", "max_issues_repo_path": "xray/hoCuCBOS_reconstruct.cpp", "max_issues_repo_name": "ahsanjav/gt-tomography", "max_issues_repo_head_hexsha": "1f53d72672ccda417bc8966d8497af6d786e8935", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "xray/hoCuCBOS_reconstruct.cpp", "max_forks_repo_name": "ahsanjav/gt-tomography", "max_forks_repo_head_hexsha": "1f53d72672ccda417bc8966d8497af6d786e8935", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-09-27T14:37:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-27T14:37:29.000Z", "avg_line_length": 36.3240938166, "max_line_length": 229, "alphanum_fraction": 0.7218830711, "num_tokens": 4726, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7606506418255927, "lm_q2_score": 0.3923368301671084, "lm_q1q2_score": 0.2984312616784296}} {"text": "// This file is part of Eigen, a lightweight C++ template library\n// for linear algebra.\n//\n// Copyright (C) 2009 Ilya Baran \n//\n// This Source Code Form is subject to the terms of the Mozilla\n// Public License v. 2.0. If a copy of the MPL was not distributed\n// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\n#ifndef KDBVH_H_INCLUDED\n#define KDBVH_H_INCLUDED\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"../BVHLeaf.hpp\"\n\nnamespace Eigen { \n\nnamespace internal {\n\n//internal pair class for the BVH--used instead of std::pair because of alignment\ntemplate\nstruct vector_int_pair\n{\nEIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Dim)\n typedef Eigen::Matrix VectorType;\n\n vector_int_pair(const VectorType &v, int i) : first(v), second(i) {}\n\n VectorType first;\n int second;\n};\n\n//these templates help the tree initializer get the bounding boxes either from a provided\n//iterator range or using bounding_box in a unified way\ntemplate\nstruct get_boxes_helper {\n void operator()(const ObjectList &objects, BoxIter boxBegin, BoxIter boxEnd, VolumeList &outBoxes)\n {\n outBoxes.insert(outBoxes.end(), boxBegin, boxEnd);\n eigen_assert(outBoxes.size() == objects.size());\n }\n};\n\ntemplate\nstruct get_boxes_helper {\n void operator()(const ObjectList &objects, int, int, VolumeList &outBoxes)\n {\n outBoxes.reserve(objects.size());\n for(int i = 0; i < (int)objects.size(); ++i)\n outBoxes.push_back(bounding_box(objects[i]));\n }\n};\n\n} // end namespace internal\n\n\n/** \\class KdBVH\n * \\brief A simple bounding volume hierarchy based on AlignedBox\n *\n * \\param _Scalar The underlying scalar type of the bounding boxes\n * \\param _Dim The dimension of the space in which the hierarchy lives\n * \\param _Object The object type that lives in the hierarchy. It must have value semantics. Either bounding_box(_Object) must\n * be defined and return an AlignedBox<_Scalar, _Dim> or bounding boxes must be provided to the tree initializer.\n *\n * This class provides a simple (as opposed to optimized) implementation of a bounding volume hierarchy analogous to a Kd-tree.\n * Given a sequence of objects, it computes their bounding boxes, constructs a Kd-tree of their centers\n * and builds a BVH with the structure of that Kd-tree. When the elements of the tree are too expensive to be copied around,\n * it is useful for _Object to be a pointer.\n */\ntemplate class KdBVH\n{\npublic:\n enum { Dim = _Dim };\n typedef _Object Object;\n typedef std::vector > ObjectList;\n typedef _Scalar Scalar;\n //typedef AlignedBox Volume;\n typedef mcl::BoundingBox Volume;\n typedef std::vector > VolumeList;\n typedef int Index;\n typedef const int *VolumeIterator; //the iterators are just pointers into the tree's vectors\n typedef const Object *ObjectIterator;\n\n KdBVH() {}\n\n /** Given an iterator range over \\a Object references, constructs the BVH. Requires that bounding_box(Object) return a Volume. */\n template KdBVH(Iter begin, Iter end) { init(begin, end, 0, 0); } //int is recognized by init as not being an iterator type\n\n /** Given an iterator range over \\a Object references and an iterator range over their bounding boxes, constructs the BVH */\n template KdBVH(OIter begin, OIter end, BIter boxBegin, BIter boxEnd) { init(begin, end, boxBegin, boxEnd); }\n\n /** Given an iterator range over \\a Object references, constructs the BVH, overwriting whatever is in there currently.\n * Requires that bounding_box(Object) return a Volume. */\n template void init(Iter begin, Iter end) { init(begin, end, 0, 0); }\n\n /** Given an iterator range over \\a Object references and an iterator range over their bounding boxes,\n * constructs the BVH, overwriting whatever is in there currently. */\n template void init(OIter begin, OIter end, BIter boxBegin, BIter boxEnd)\n {\n objects.clear();\n boxes.clear();\n children.clear();\n\n objects.insert(objects.end(), begin, end);\n int n = static_cast(objects.size());\n\n if(n < 2)\n return; //if we have at most one object, we don't need any internal nodes\n\n VolumeList objBoxes;\n VIPairList objCenters;\n\n //compute the bounding boxes depending on BIter type\n internal::get_boxes_helper()(objects, boxBegin, boxEnd, objBoxes);\n\n objCenters.reserve(n);\n boxes.reserve(n - 1);\n children.reserve(2 * n - 2);\n\n for(int i = 0; i < n; ++i)\n objCenters.push_back(VIPair(objBoxes[i].center(), i));\n\n build(objCenters, 0, n, objBoxes, 0); //the recursive part of the algorithm\n\n ObjectList tmp(n);\n tmp.swap(objects);\n for(int i = 0; i < n; ++i)\n objects[i] = tmp[objCenters[i].second];\n }\n\n /** \\returns the index of the root of the hierarchy */\n inline Index getRootIndex() const { return (int)boxes.size() - 1; }\n\n /** Given an \\a index of a node, on exit, \\a outVBegin and \\a outVEnd range over the indices of the volume children of the node\n * and \\a outOBegin and \\a outOEnd range over the object children of the node */\n EIGEN_STRONG_INLINE void getChildren(Index index, VolumeIterator &outVBegin, VolumeIterator &outVEnd,\n ObjectIterator &outOBegin, ObjectIterator &outOEnd) const\n { //inlining this function should open lots of optimization opportunities to the compiler\n if(index < 0) {\n outVBegin = outVEnd;\n if(!objects.empty())\n outOBegin = &(objects[0]);\n outOEnd = outOBegin + objects.size(); //output all objects--necessary when the tree has only one object\n return;\n }\n\n int numBoxes = static_cast(boxes.size());\n\n int idx = index * 2;\n if(children[idx + 1] < numBoxes) { //second index is always bigger\n outVBegin = &(children[idx]);\n outVEnd = outVBegin + 2;\n outOBegin = outOEnd;\n }\n else if(children[idx] >= numBoxes) { //if both children are objects\n outVBegin = outVEnd;\n outOBegin = &(objects[children[idx] - numBoxes]);\n outOEnd = outOBegin + 2;\n } else { //if the first child is a volume and the second is an object\n outVBegin = &(children[idx]);\n outVEnd = outVBegin + 1;\n outOBegin = &(objects[children[idx + 1] - numBoxes]);\n outOEnd = outOBegin + 1;\n }\n }\n\n /** \\returns the bounding box of the node at \\a index */\n inline const Volume &getVolume(Index index) const\n {\n return boxes[index];\n }\n\nprivate:\n typedef internal::vector_int_pair VIPair;\n typedef std::vector > VIPairList;\n typedef Matrix VectorType;\n struct VectorComparator //compares vectors, or, more specificall, VIPairs along a particular dimension\n {\n VectorComparator(int inDim) : dim(inDim) {}\n inline bool operator()(const VIPair &v1, const VIPair &v2) const { return v1.first[dim] < v2.first[dim]; }\n int dim;\n };\n\n //Build the part of the tree between objects[from] and objects[to] (not including objects[to]).\n //This routine partitions the objCenters in [from, to) along the dimension dim, recursively constructs\n //the two halves, and adds their parent node. TODO: a cache-friendlier layout\n void build(VIPairList &objCenters, int from, int to, const VolumeList &objBoxes, int dim)\n {\n eigen_assert(to - from > 1);\n if(to - from == 2) {\n boxes.push_back(objBoxes[objCenters[from].second].merged(objBoxes[objCenters[from + 1].second]));\n children.push_back(from + (int)objects.size() - 1); //there are objects.size() - 1 tree nodes\n children.push_back(from + (int)objects.size());\n }\n else if(to - from == 3) {\n int mid = from + 2;\n std::nth_element(objCenters.begin() + from, objCenters.begin() + mid,\n objCenters.begin() + to, VectorComparator(dim)); //partition\n build(objCenters, from, mid, objBoxes, (dim + 1) % Dim);\n int idx1 = (int)boxes.size() - 1;\n boxes.push_back(boxes[idx1].merged(objBoxes[objCenters[mid].second]));\n children.push_back(idx1);\n children.push_back(mid + (int)objects.size() - 1);\n }\n else {\n int mid = from + (to - from) / 2;\n nth_element(objCenters.begin() + from, objCenters.begin() + mid,\n objCenters.begin() + to, VectorComparator(dim)); //partition\n build(objCenters, from, mid, objBoxes, (dim + 1) % Dim);\n int idx1 = (int)boxes.size() - 1;\n build(objCenters, mid, to, objBoxes, (dim + 1) % Dim);\n int idx2 = (int)boxes.size() - 1;\n boxes.push_back(boxes[idx1].merged(boxes[idx2]));\n children.push_back(idx1);\n children.push_back(idx2);\n }\n }\n\n std::vector children; //children of x are children[2x] and children[2x+1], indices bigger than boxes.size() index into objects.\n VolumeList boxes;\n ObjectList objects;\n};\n\n} // end namespace Eigen\n\n#endif //KDBVH_H_INCLUDED\n", "meta": {"hexsha": "c69afc8fd4478fcffc88b372d1130060383bf67a", "size": 9331, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/MCL/ccd_internal/KdBVH.hpp", "max_stars_repo_name": "mattoverby/mclccd", "max_stars_repo_head_hexsha": "2137e4edee822c62c4aa5485cb83d7f8191c950c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/MCL/ccd_internal/KdBVH.hpp", "max_issues_repo_name": "mattoverby/mclccd", "max_issues_repo_head_hexsha": "2137e4edee822c62c4aa5485cb83d7f8191c950c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/MCL/ccd_internal/KdBVH.hpp", "max_forks_repo_name": "mattoverby/mclccd", "max_forks_repo_head_hexsha": "2137e4edee822c62c4aa5485cb83d7f8191c950c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.2198275862, "max_line_length": 142, "alphanum_fraction": 0.6913514093, "num_tokens": 2428, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.626124191181315, "lm_q2_score": 0.47657965106367595, "lm_q1q2_score": 0.29839804855571744}} {"text": "#ifndef GRAPHS_H_\n#define GRAPHS_H_\n\n#include \n#include \n#include \n#include \"multi_array.hpp\"\n\nnamespace graphs {\n\ntypedef std::size_t NodeID;\ntypedef std::size_t Index;\n\ntemplate\nstruct EdgeTail {\n\n EdgeTail() {\n source = 0;\n weight = 1;\n }\n\n EdgeTail(NodeID source_node, TReal source_weight) : \n source(source_node), weight(source_weight) {}\n\n NodeID source;\n TReal weight;\n};\n\ntemplate<>\nstruct EdgeTail {\n\n EdgeTail() {\n source = 0;\n }\n\n EdgeTail(NodeID source_node) : \n source(source_node) {}\n\n NodeID source;\n};\n\ntemplate\nclass PredecessorGraph {\n public:\n typedef std::size_t NodeID;\n typedef std::size_t Index;\n\n /*\n * When building from an edge list it is assumed nodes are labelled\n * contiguously starting from 0 to num_nodes-1\n */\n PredecessorGraph() : PredecessorGraph(0) {\n }\n\n PredecessorGraph(NodeID num_nodes)\n : num_nodes_(num_nodes) {\n graph_.resize(num_nodes);\n num_edges_ = 0;\n for (NodeID iii = 0; iii < num_nodes; ++iii) {\n graph_[iii].resize(0);\n }\n }\n\n PredecessorGraph(const std::vector< std::vector> >& graph) : graph_(graph) {\n num_nodes_ = graph_.size();\n num_edges_ = CalcNumEdges();\n }\n\n PredecessorGraph(const PredecessorGraph& other) : graph_(other.graph_),\n num_nodes_(other.num_nodes_), num_edges_(other.num_edges_) {}\n\n PredecessorGraph(PredecessorGraph&& other) : graph_(std::move(other.graph_)),\n num_nodes_(std::move(other.num_nodes_)), \n num_edges_(std::move(other.num_edges_)) {}\n\n PredecessorGraph& operator=(const PredecessorGraph& other) {\n graph_ = other.graph_;\n num_nodes_ = other.num_nodes_;\n num_edges_ = other.num_edges_;\n return *this;\n }\n\n PredecessorGraph& operator=(PredecessorGraph&& other) {\n graph_ = std::move(other.graph_);\n num_nodes_ = std::move(other.num_nodes_);\n num_edges_ = std::move(other.num_edges_);\n return *this;\n }\n\n std::size_t CalcNumEdges() const {\n std::size_t sum = 0;\n for (NodeID iii = 0; iii < graph_.size(); iii++) {\n sum += graph_[iii].size();\n }\n\n return sum;\n }\n\n std::size_t NumEdges() const {\n return num_edges_;\n }\n\n std::size_t NumNodes() const {\n return num_nodes_;\n }\n\n const std::vector>& Predecessors(NodeID node) const {\n return graph_[node];\n }\n\n void AddEdge(NodeID source, NodeID target, TReal weight=1) {\n // It is assumed the Node should exist, so new nodes are added\n // up to the NodeID of the source or target\n if (source >= num_nodes_) {\n std::size_t num_new_nodes = source - num_nodes_ + 1;\n for (Index iii = 0; iii < num_new_nodes; ++iii) {\n graph_.push_back(std::vector>(0));\n ++num_nodes_;\n }\n }\n\n if (target >= num_nodes_) {\n std::size_t num_new_nodes = target - num_nodes_ + 1;\n for (Index iii = 0; iii < num_new_nodes; ++iii) {\n graph_.push_back(std::vector>(0));\n ++num_nodes_;\n }\n }\n\n graph_[target].push_back(EdgeTail(source, weight));\n ++num_edges_;\n }\n\n protected:\n std::vector< std::vector> > graph_;\n std::size_t num_nodes_;\n std::size_t num_edges_;\n};\n\ntemplate<>\nclass PredecessorGraph {\n public:\n typedef std::size_t NodeID;\n typedef std::size_t Index;\n\n /*\n * When building from an edge list it is assumed nodes are labelled\n * contiguously starting from 0 to num_nodes-1\n */\n PredecessorGraph() : PredecessorGraph(0) {\n }\n\n PredecessorGraph(NodeID num_nodes)\n : num_nodes_(num_nodes) {\n graph_.resize(num_nodes);\n num_edges_ = 0;\n for (NodeID iii = 0; iii < num_nodes; ++iii) {\n graph_[iii].resize(0);\n }\n }\n\n PredecessorGraph(const std::vector< std::vector> >& graph) : graph_(graph) {\n num_nodes_ = graph_.size();\n num_edges_ = CalcNumEdges();\n }\n\n PredecessorGraph(const PredecessorGraph& other) : graph_(other.graph_),\n num_nodes_(other.num_nodes_), num_edges_(other.num_edges_) {}\n\n PredecessorGraph(PredecessorGraph&& other) : graph_(std::move(other.graph_)),\n num_nodes_(std::move(other.num_nodes_)), \n num_edges_(std::move(other.num_edges_)) {}\n\n PredecessorGraph& operator=(const PredecessorGraph& other) {\n graph_ = other.graph_;\n num_nodes_ = other.num_nodes_;\n num_edges_ = other.num_edges_;\n return *this;\n }\n\n PredecessorGraph& operator=(PredecessorGraph&& other) {\n graph_ = std::move(other.graph_);\n num_nodes_ = std::move(other.num_nodes_);\n num_edges_ = std::move(other.num_edges_);\n return *this;\n }\n\n std::size_t CalcNumEdges() const {\n std::size_t sum = 0;\n for (NodeID iii = 0; iii < graph_.size(); iii++) {\n sum += graph_[iii].size();\n }\n\n return sum;\n }\n\n std::size_t NumEdges() const {\n return num_edges_;\n }\n\n std::size_t NumNodes() const {\n return num_nodes_;\n }\n\n const std::vector>& Predecessors(NodeID node) const {\n return graph_[node];\n }\n\n // Automatically resizes graph if new nodes are introduced\n void AddEdge(NodeID source, NodeID target) {\n // It is assumed the Node should exist, so new nodes are added\n // up to the NodeID of the source or target\n if (source >= num_nodes_) {\n std::size_t num_new_nodes = source - num_nodes_ + 1;\n for (Index iii = 0; iii < num_new_nodes; ++iii) {\n graph_.push_back(std::vector>(0));\n ++num_nodes_;\n }\n }\n\n if (target >= num_nodes_) {\n std::size_t num_new_nodes = target - num_nodes_ + 1;\n for (Index iii = 0; iii < num_new_nodes; ++iii) {\n graph_.push_back(std::vector>(0));\n ++num_nodes_;\n }\n }\n\n graph_[target].push_back(EdgeTail<>(source));\n ++num_edges_;\n }\n\n protected:\n std::vector< std::vector> > graph_;\n std::size_t num_nodes_;\n std::size_t num_edges_;\n};\n\n/*\n * edge list may exclude end nodes if they aren't connected, so it is\n * insufficient to just pass a node list.\n * First dimension is NumEdges, second dimension is [source, target]\n * If there are weights then pass weight array (must be same size as edges)\n */\n\ntemplate class multi>\nPredecessorGraph<> ConvertEdgeListToPredecessorGraph(const multi& edge_list) {\n PredecessorGraph<> graph = PredecessorGraph<>();\n const multi_array::ArrayView edge_view = edge_list.accessor();\n for (Index iii = 0; iii < edge_view.extent(0); ++iii) {\n graph.AddEdge(edge_view[iii][0], edge_view[iii][1]);\n }\n\n return graph;\n}\n\ntemplate class multi>\nPredecessorGraph ConvertEdgeListToPredecessorGraph(const multi& edge_list,\n const multi& weights) {\n PredecessorGraph graph = PredecessorGraph();\n const multi_array::ArrayView edge_view = edge_list.accessor();\n const multi_array::ArrayView weight_view = weights.accessor();\n for (Index iii = 0; iii < edge_view.extent(0); ++iii) {\n graph.AddEdge(edge_view[iii][0], edge_view[iii][1], weight_view[iii]);\n }\n\n return graph;\n}\n\n/*\n * Converts an edge list into a sparse matrix. The tail_size, is the number\n * of nodes that act as the source of the links, and head_size is the number\n * of nodes that act as the sink of the links. For a standard graph this is\n * just the total number of nodes in the graph, else if the graph is\n * bipartite, then one will be larger than the other.\n * For edge list, the order of the list should be row-major\n * with shape Ex2 with major axis as the edge with (tail, head) so that\n * X[edge#][0]=tail, X[edge#][1]=head\n *\n * Because Eigen uses Fortran's column major format, the ordering will be\n * reversed in order to preserve the proper direction of the links in the\n * sparse matrix.\n *\n * The resulting sparse matrix shape is: Head x Tail\n * Where Tail == # cols, and Head == # rows\n */\ntemplate class multi, typename Integer>\nEigen::SparseMatrix ConvertEdgeListToSparseMatrix(const multi& edge_list,\n const int num_tail_nodes,\n const int num_head_nodes) {\n\n const auto edge_view = edge_list.accessor();\n std::vector> matrix_elements(edge_view.extent(0));\n for (std::size_t i = 0; i < edge_view.extent(0); ++i) {\n matrix_elements[i] = Eigen::Triplet(static_cast(edge_view[i][1]),\n static_cast(edge_view[i][0]), 1);\n }\n Eigen::SparseMatrix graph(num_head_nodes, num_tail_nodes);\n graph.setFromTriplets(matrix_elements.begin(), matrix_elements.end());\n\n return graph;\n};\n\ntemplate class MultiArray2D,\n template class MultiArray1D, typename Integer>\nEigen::SparseMatrix ConvertEdgeListToSparseMatrix(const MultiArray2D& edge_list,\n const int num_tail_nodes,\n const int num_head_nodes,\n const MultiArray1D& weights) {\n\n const auto edge_view = edge_list.accessor();\n const auto weight_view = weights.accessor();\n std::vector> matrix_elements(edge_view.extent(0));\n for (std::size_t i = 0; i < edge_view.extent(0); ++i) {\n matrix_elements[i] = Eigen::Triplet(static_cast(edge_view[i][1]),\n static_cast(edge_view[i][0]),\n weight_view[i]);\n }\n Eigen::SparseMatrix graph(num_head_nodes, num_tail_nodes);\n graph.setFromTriplets(matrix_elements.begin(), matrix_elements.end());\n\n return graph;\n};\n\n} // End graphs namespace\n\n#endif /* GRAPHS_H_ */", "meta": {"hexsha": "33df301278db8e2f24dc087374cbc513cfec5939", "size": 10395, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "alectrnn/common/graphs.hpp", "max_stars_repo_name": "neuro-evolution/alectrnn", "max_stars_repo_head_hexsha": "f39476b6eb3f4270c5f7f2f93ebcc5940b9c39e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "alectrnn/common/graphs.hpp", "max_issues_repo_name": "neuro-evolution/alectrnn", "max_issues_repo_head_hexsha": "f39476b6eb3f4270c5f7f2f93ebcc5940b9c39e4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 33.0, "max_issues_repo_issues_event_min_datetime": "2018-03-30T03:18:03.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-14T05:13:17.000Z", "max_forks_repo_path": "alectrnn/common/graphs.hpp", "max_forks_repo_name": "Nathaniel-Rodriguez/alectrnn", "max_forks_repo_head_hexsha": "f39476b6eb3f4270c5f7f2f93ebcc5940b9c39e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.7889908257, "max_line_length": 99, "alphanum_fraction": 0.6354016354, "num_tokens": 2641, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6261241772283034, "lm_q2_score": 0.476579651063676, "lm_q1q2_score": 0.29839804190599606}} {"text": "//=======================================================================\r\n// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.\r\n// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek\r\n//\r\n// Distributed under the Boost Software License, Version 1.0. (See\r\n// accompanying file LICENSE_1_0.txt or copy at\r\n// http://www.boost.org/LICENSE_1_0.txt)\r\n//=======================================================================\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n\r\ntemplate \r\nclass calc_distance_visitor : public boost::bfs_visitor<>\r\n{\r\npublic:\r\n calc_distance_visitor(Distance d) : distance(d) { }\r\n\r\n template \r\n void tree_edge(typename boost::graph_traits::edge_descriptor e,\r\n Graph& g)\r\n {\r\n typename boost::graph_traits::vertex_descriptor u, v;\r\n u = boost::source(e, g);\r\n v = boost::target(e, g);\r\n distance[v] = distance[u] + 1;\r\n }\r\nprivate:\r\n Distance distance;\r\n};\r\n\r\n\r\ntemplate \r\nclass print_tree_visitor : public boost::dfs_visitor<>\r\n{\r\npublic:\r\n print_tree_visitor(VertexNameMap n, DistanceMap d) : name(n), distance(d) { }\r\n template \r\n void \r\n discover_vertex(typename boost::graph_traits::vertex_descriptor v,\r\n Graph&)\r\n {\r\n typedef typename boost::property_traits::value_type Dist;\r\n // indentation based on depth\r\n for (Dist i = 0; i < distance[v]; ++i)\r\n std::cout << \" \";\r\n std::cout << name[v] << std::endl;\r\n }\r\n\r\n template \r\n void tree_edge(typename boost::graph_traits::edge_descriptor e,\r\n Graph& g)\r\n {\r\n distance[boost::target(e, g)] = distance[boost::source(e, g)] + 1;\r\n } \r\n\r\nprivate:\r\n VertexNameMap name;\r\n DistanceMap distance;\r\n};\r\n\r\nint\r\nmain()\r\n{\r\n using namespace boost;\r\n\r\n std::ifstream datafile(\"./boost_web.dat\");\r\n if (!datafile) {\r\n std::cerr << \"No ./boost_web.dat file\" << std::endl;\r\n return -1;\r\n }\r\n\r\n //===========================================================================\r\n // Declare the graph type and object, and some property maps.\r\n\r\n typedef adjacency_list >,\r\n property >\r\n > Graph;\r\n\r\n typedef graph_traits Traits;\r\n typedef Traits::vertex_descriptor Vertex;\r\n typedef Traits::edge_descriptor Edge;\r\n\r\n typedef std::map NameVertexMap;\r\n NameVertexMap name2vertex;\r\n Graph g;\r\n\r\n typedef property_map::type NameMap;\r\n NameMap node_name = get(vertex_name, g);\r\n property_map::type link_name = get(edge_name, g);\r\n\r\n //===========================================================================\r\n // Read the data file and construct the graph.\r\n \r\n std::string line;\r\n while (std::getline(datafile,line)) {\r\n\r\n std::list line_toks;\r\n boost::stringtok(line_toks, line, \"|\");\r\n\r\n NameVertexMap::iterator pos; \r\n bool inserted;\r\n Vertex u, v;\r\n\r\n std::list::iterator i = line_toks.begin();\r\n\r\n boost::tie(pos, inserted) = name2vertex.insert(std::make_pair(*i, Vertex()));\r\n if (inserted) {\r\n u = add_vertex(g);\r\n put(node_name, u, *i);\r\n pos->second = u;\r\n } else\r\n u = pos->second;\r\n ++i;\r\n\r\n std::string hyperlink_name = *i++;\r\n \r\n boost::tie(pos, inserted) = name2vertex.insert(std::make_pair(*i, Vertex()));\r\n if (inserted) {\r\n v = add_vertex(g);\r\n put(node_name, v, *i);\r\n pos->second = v;\r\n } else\r\n v = pos->second;\r\n\r\n Edge e;\r\n boost::tie(e, inserted) = add_edge(u, v, g);\r\n if (inserted) {\r\n put(link_name, e, hyperlink_name);\r\n }\r\n }\r\n\r\n //===========================================================================\r\n // Calculate the diameter of the graph.\r\n\r\n typedef Traits::vertices_size_type size_type;\r\n typedef std::vector IntVector;\r\n // Create N x N matrix for storing the shortest distances\r\n // between each vertex. Initialize all distances to zero.\r\n std::vector d_matrix(num_vertices(g),\r\n IntVector(num_vertices(g), 0));\r\n\r\n size_type i;\r\n for (i = 0; i < num_vertices(g); ++i) {\r\n calc_distance_visitor vis(&d_matrix[i][0]);\r\n Traits::vertex_descriptor src = vertices(g).first[i];\r\n breadth_first_search(g, src, boost::visitor(vis));\r\n }\r\n\r\n size_type diameter = 0;\r\n BOOST_USING_STD_MAX();\r\n for (i = 0; i < num_vertices(g); ++i)\r\n diameter = max BOOST_PREVENT_MACRO_SUBSTITUTION(diameter, *std::max_element(d_matrix[i].begin(), \r\n d_matrix[i].end()));\r\n \r\n std::cout << \"The diameter of the boost web-site graph is \" << diameter\r\n << std::endl << std::endl;\r\n\r\n std::cout << \"Number of clicks from the home page: \" << std::endl;\r\n Traits::vertex_iterator vi, vi_end;\r\n for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)\r\n std::cout << d_matrix[0][*vi] << \"\\t\" << node_name[*vi] << std::endl;\r\n std::cout << std::endl;\r\n \r\n //===========================================================================\r\n // Print out the breadth-first search tree starting at the home page\r\n\r\n // Create storage for a mapping from vertices to their parents\r\n std::vector parent(num_vertices(g));\r\n for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)\r\n parent[*vi] = *vi;\r\n\r\n // Do a BFS starting at the home page, recording the parent of each\r\n // vertex (where parent is with respect to the search tree).\r\n Traits::vertex_descriptor src = vertices(g).first[0];\r\n breadth_first_search\r\n (g, src, \r\n boost::visitor(make_bfs_visitor(record_predecessors(&parent[0],\r\n on_tree_edge()))));\r\n\r\n // Add all the search tree edges into a new graph\r\n Graph search_tree(num_vertices(g));\r\n boost::tie(vi, vi_end) = vertices(g);\r\n ++vi;\r\n for (; vi != vi_end; ++vi)\r\n add_edge(parent[*vi], *vi, search_tree);\r\n\r\n std::cout << \"The breadth-first search tree:\" << std::endl;\r\n\r\n // Print out the search tree. We use DFS because it visits\r\n // the tree nodes in the order that we want to print out:\r\n // a directory-structure like format.\r\n std::vector dfs_distances(num_vertices(g), 0);\r\n print_tree_visitor\r\n tree_printer(node_name, &dfs_distances[0]);\r\n for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)\r\n get(vertex_color, g)[*vi] = white_color;\r\n depth_first_visit(search_tree, src, tree_printer, get(vertex_color, g));\r\n \r\n return EXIT_SUCCESS;\r\n}\r\n", "meta": {"hexsha": "4f56c3702aa9266253c3c34a7155b47031cd23c6", "size": 7157, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "libs/graph/example/boost_web_graph.cpp", "max_stars_repo_name": "zyiacas/boost-doc-zh", "max_stars_repo_head_hexsha": "689e5a3a0a4dbead1a960f7b039e3decda54aa2c", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 198.0, "max_stars_repo_stars_event_min_datetime": "2015-01-13T05:47:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T04:46:46.000Z", "max_issues_repo_path": "libs/graph/example/boost_web_graph.cpp", "max_issues_repo_name": "sdfict/boost-doc-zh", "max_issues_repo_head_hexsha": "689e5a3a0a4dbead1a960f7b039e3decda54aa2c", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 9.0, "max_issues_repo_issues_event_min_datetime": "2015-01-28T16:33:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-12T23:03:28.000Z", "max_forks_repo_path": "libs/graph/example/boost_web_graph.cpp", "max_forks_repo_name": "sdfict/boost-doc-zh", "max_forks_repo_head_hexsha": "689e5a3a0a4dbead1a960f7b039e3decda54aa2c", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 139.0, "max_forks_repo_forks_event_min_datetime": "2015-01-15T20:09:31.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-31T15:21:16.000Z", "avg_line_length": 33.4439252336, "max_line_length": 102, "alphanum_fraction": 0.5949420148, "num_tokens": 1737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.523420348936324, "lm_q2_score": 0.5698526514141571, "lm_q1q2_score": 0.29827247364548753}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifndef SDF_HPP\n#define SDF_HPP\n\nnamespace sdf_tools\n{\nusing VoxelGrid::GRID_INDEX;\n\nclass SignedDistanceField : public VoxelGrid::VoxelGrid\n{\nprotected:\n\n std::string frame_;\n bool locked_;\n\n /*\n * You *MUST* provide valid indices to this function, hence why it is\n * protected (there are safe wrappers available - use them!)\n */\n void FollowGradientsToLocalExtremaUnsafe(\n VoxelGrid& watershed_map,\n const int64_t x_index,\n const int64_t y_index,\n const int64_t z_index) const;\n\n bool GradientIsEffectiveFlat(const Eigen::Vector3d& gradient) const;\n\n GRID_INDEX GetNextFromGradient(const GRID_INDEX& index,\n const Eigen::Vector3d& gradient) const;\n\npublic:\n\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n\n inline SignedDistanceField(const std::string& frame,\n double resolution,\n double x_size,\n double y_size,\n double z_size,\n float OOB_value)\n : VoxelGrid::VoxelGrid(resolution,\n x_size, y_size, z_size,\n OOB_value),\n frame_(frame), locked_(false) {}\n\n inline SignedDistanceField(const Eigen::Isometry3d& origin_transform,\n const std::string& frame,\n double resolution,\n double x_size,\n double y_size,\n double z_size,\n float OOB_value)\n : VoxelGrid::VoxelGrid(origin_transform, resolution,\n x_size, y_size, z_size,\n OOB_value),\n frame_(frame), locked_(false) {}\n\n inline SignedDistanceField(const std::string& frame,\n double resolution,\n int64_t x_cells,\n int64_t y_cells,\n int64_t z_cells,\n float OOB_value)\n : VoxelGrid::VoxelGrid(resolution,\n x_cells, y_cells, z_cells,\n OOB_value),\n frame_(frame), locked_(false) {}\n\n inline SignedDistanceField(const Eigen::Isometry3d& origin_transform,\n const std::string& frame,\n double resolution,\n int64_t x_cells,\n int64_t y_cells,\n int64_t z_cells,\n float OOB_value)\n : VoxelGrid::VoxelGrid(origin_transform, resolution,\n x_cells, y_cells, z_cells,\n OOB_value),\n frame_(frame), locked_(false) {}\n\n inline SignedDistanceField()\n : VoxelGrid::VoxelGrid(), frame_(\"\"), locked_(false) {}\n\n virtual VoxelGrid* Clone() const\n {\n return new SignedDistanceField(\n static_cast(*this));\n }\n\n inline bool IsLocked() const\n {\n return locked_;\n }\n\n inline void Lock()\n {\n locked_ = true;\n }\n\n inline void Unlock()\n {\n locked_ = false;\n }\n\n virtual uint64_t SerializeSelf(\n std::vector& buffer,\n const std::function&)>& value_serializer\n =arc_helpers::SerializeFixedSizePOD) const;\n\n virtual uint64_t DeserializeSelf(\n const std::vector& buffer, const uint64_t current,\n const std::function(\n const std::vector&, const uint64_t)>& value_deserializer\n =arc_helpers::DeserializeFixedSizePOD);\n\n /*\n * Mutable access and setter functions MUST be used carefully!\n * If you arbitrarily change SDF values, it is not a proper SDF any more!\n *\n * Use of these functions can be prevented by calling\n * SignedDistanceField::Lock() on the SDF\n */\n\n virtual std::pair GetMutable3d(\n const Eigen::Vector3d& location)\n {\n const GRID_INDEX index = LocationToGridIndex3d(location);\n if (IndexInBounds(index))\n {\n return GetMutable(index);\n }\n else\n {\n return std::pair(oob_value_, false);\n }\n }\n\n virtual std::pair GetMutable4d(\n const Eigen::Vector4d& location)\n {\n const GRID_INDEX index = LocationToGridIndex4d(location);\n if (IndexInBounds(index))\n {\n return GetMutable(index);\n }\n else\n {\n return std::pair(oob_value_, false);\n }\n }\n\n virtual std::pair GetMutable(const double x,\n const double y,\n const double z)\n {\n const Eigen::Vector4d location(x, y, z, 1.0);\n return GetMutable4d(location);\n }\n\n virtual std::pair GetMutable(const GRID_INDEX& index)\n {\n if (IndexInBounds(index) && !locked_)\n {\n return std::pair(\n AccessIndex(GetDataIndex(index)), true);\n }\n else\n {\n return std::pair(oob_value_, false);\n }\n }\n\n virtual std::pair GetMutable(const int64_t x_index,\n const int64_t y_index,\n const int64_t z_index)\n {\n if (IndexInBounds(x_index, y_index, z_index) && !locked_)\n {\n return std::pair(\n AccessIndex(GetDataIndex(x_index, y_index, z_index)), true);\n }\n else\n {\n return std::pair(oob_value_, false);\n }\n }\n\n virtual bool SetValue3d(const Eigen::Vector3d& location,\n const float& value)\n {\n const GRID_INDEX index = LocationToGridIndex3d(location);\n if (IndexInBounds(index))\n {\n return SetValue(index, value);\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue4d(const Eigen::Vector4d& location,\n const float& value)\n {\n const GRID_INDEX index = LocationToGridIndex4d(location);\n if (IndexInBounds(index))\n {\n return SetValue(index, value);\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue(const double x,\n const double y,\n const double z,\n const float& value)\n {\n const Eigen::Vector4d location(x, y, z, 1.0);\n return SetValue4d(location, value);\n }\n\n virtual bool SetValue(const GRID_INDEX& index,\n const float& value)\n {\n if (IndexInBounds(index) && !locked_)\n {\n AccessIndex(GetDataIndex(index)) = value;\n return true;\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue(const int64_t x_index,\n const int64_t y_index,\n const int64_t z_index,\n const float& value)\n {\n if (IndexInBounds(x_index, y_index, z_index) && !locked_)\n {\n AccessIndex(GetDataIndex(x_index, y_index, z_index)) = value;\n return true;\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue3d(const Eigen::Vector3d& location,\n float&& value)\n {\n const GRID_INDEX index = LocationToGridIndex3d(location);\n if (IndexInBounds(index))\n {\n return SetValue(index, value);\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue4d(const Eigen::Vector4d& location,\n float&& value)\n {\n const GRID_INDEX index = LocationToGridIndex4d(location);\n if (IndexInBounds(index))\n {\n return SetValue(index, value);\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue(const double x,\n const double y,\n const double z,\n float&& value)\n {\n const Eigen::Vector4d location(x, y, z, 1.0);\n return SetValue4d(location, value);\n }\n\n virtual bool SetValue(const GRID_INDEX& index,\n float&& value)\n {\n if (IndexInBounds(index) && !locked_)\n {\n AccessIndex(GetDataIndex(index)) = value;\n return true;\n }\n else\n {\n return false;\n }\n }\n\n virtual bool SetValue(const int64_t x_index,\n const int64_t y_index,\n const int64_t z_index,\n float&& value)\n {\n if (IndexInBounds(x_index, y_index, z_index) && !locked_)\n {\n AccessIndex(GetDataIndex(x_index, y_index, z_index)) = value;\n return true;\n }\n else\n {\n return false;\n }\n }\n\n inline double GetResolution() const { return GetCellSizes().x(); }\n\n inline std::string GetFrame() const\n {\n return frame_;\n }\n\n inline std::vector GetGradient(\n const double x, const double y, const double z,\n const bool enable_edge_gradients=false) const\n {\n return GetGradient4d(Eigen::Vector4d(x, y, z, 1.0), enable_edge_gradients);\n }\n\n inline std::vector GetGradient3d(\n const Eigen::Vector3d& location,\n const bool enable_edge_gradients=false) const\n {\n const GRID_INDEX index = LocationToGridIndex3d(location);\n if (IndexInBounds(index))\n {\n return GetGradient(index, enable_edge_gradients);\n }\n else\n {\n return std::vector();\n }\n }\n\n inline std::vector GetGradient4d(\n const Eigen::Vector4d& location,\n const bool enable_edge_gradients=false) const\n {\n const GRID_INDEX index = LocationToGridIndex4d(location);\n if (IndexInBounds(index))\n {\n return GetGradient(index, enable_edge_gradients);\n }\n else\n {\n return std::vector();\n }\n }\n\n inline std::vector GetGradient(\n const GRID_INDEX& index,\n const bool enable_edge_gradients=false) const\n {\n return GetGradient(index.x, index.y, index.z, enable_edge_gradients);\n }\n\n inline std::vector GetGradient(\n const int64_t x_index, const int64_t y_index, const int64_t z_index,\n const bool enable_edge_gradients=false) const\n {\n const std::vector grid_aligned_gradient\n = GetGridAlignedGradient(x_index, y_index, z_index,\n enable_edge_gradients);\n if (grid_aligned_gradient.size() == 3)\n {\n const Eigen::Quaterniond grid_rotation(origin_transform_.rotation());\n // Derived from EigenHelpers::RotateVector, but without extra copies\n const Eigen::Quaterniond temp(0.0,\n grid_aligned_gradient[0],\n grid_aligned_gradient[1],\n grid_aligned_gradient[2]);\n const Eigen::Quaterniond result\n = grid_rotation * (temp * grid_rotation.inverse());\n return std::vector{result.x(),\n result.y(),\n result.z()};\n }\n else\n {\n return std::vector();\n }\n }\n\n inline std::vector GetGridAlignedGradient(\n const int64_t x_index, const int64_t y_index, const int64_t z_index,\n const bool enable_edge_gradients=false) const\n {\n // Make sure the index is inside bounds\n if (IndexInBounds(x_index, y_index, z_index))\n {\n // See if the index we're trying to query is one cell in from the edge\n if ((x_index > 0) && (y_index > 0) && (z_index > 0)\n && (x_index < (GetNumXCells() - 1))\n && (y_index < (GetNumYCells() - 1))\n && (z_index < (GetNumZCells() - 1)))\n {\n const double inv_twice_resolution = 1.0 / (2.0 * GetResolution());\n const double gx = (GetImmutable(x_index + 1, y_index, z_index).first\n - GetImmutable(x_index - 1, y_index, z_index).first)\n * inv_twice_resolution;\n const double gy = (GetImmutable(x_index, y_index + 1, z_index).first\n - GetImmutable(x_index, y_index - 1, z_index).first)\n * inv_twice_resolution;\n const double gz = (GetImmutable(x_index, y_index, z_index + 1).first\n - GetImmutable(x_index, y_index, z_index - 1).first)\n * inv_twice_resolution;\n return std::vector{gx, gy, gz};\n }\n // If we're on the edge, handle it specially\n // TODO: we actually need to handle corners even more carefully,\n // since if the SDF is build with a virtual border, these cells will\n // get zero gradient from this approach!\n else if (enable_edge_gradients)\n {\n // Get the \"best\" indices we can use\n const int64_t low_x_index = std::max((int64_t)0, x_index - 1);\n const int64_t high_x_index = std::min(GetNumXCells() - 1, x_index + 1);\n const int64_t low_y_index = std::max((int64_t)0, y_index - 1);\n const int64_t high_y_index = std::min(GetNumYCells() - 1, y_index + 1);\n const int64_t low_z_index = std::max((int64_t)0, z_index - 1);\n const int64_t high_z_index = std::min(GetNumZCells() - 1, z_index + 1);\n // Compute the axis increments\n const double x_increment\n = (high_x_index - low_x_index) * GetResolution();\n const double y_increment\n = (high_y_index - low_y_index) * GetResolution();\n const double z_increment\n = (high_z_index - low_z_index) * GetResolution();\n // Compute the gradients for each axis - by default these are zero\n double gx = 0.0;\n double gy = 0.0;\n double gz = 0.0;\n // Only if the increments are non-zero do we compute the axis gradient\n if (x_increment > 0.0)\n {\n const double inv_x_increment = 1.0 / x_increment;\n const double high_x_value\n = GetImmutable(high_x_index, y_index, z_index).first;\n const double low_x_value\n = GetImmutable(low_x_index, y_index, z_index).first;\n // Compute the gradient\n gx = (high_x_value - low_x_value) * inv_x_increment;\n }\n if (y_increment > 0.0)\n {\n const double inv_y_increment = 1.0 / y_increment;\n const double high_y_value\n = GetImmutable(x_index, high_y_index, z_index).first;\n const double low_y_value\n = GetImmutable(x_index, low_y_index, z_index).first;\n // Compute the gradient\n gy = (high_y_value - low_y_value) * inv_y_increment;\n }\n if (z_increment > 0.0)\n {\n const double inv_z_increment = 1.0 / z_increment;\n const double high_z_value\n = GetImmutable(x_index, y_index, high_z_index).first;\n const double low_z_value\n = GetImmutable(x_index, y_index, low_z_index).first;\n // Compute the gradient\n gz = (high_z_value - low_z_value) * inv_z_increment;\n }\n // Assemble and return the computed gradient\n return std::vector{gx, gy, gz};\n }\n // Edge gradients disabled, return no gradient\n else\n {\n return std::vector();\n }\n }\n // If we're out of bounds, return no gradient\n else\n {\n return std::vector();\n }\n }\n\n inline std::vector GetSmoothGradient3d(\n const Eigen::Vector3d& location,\n const double nominal_window_size) const\n {\n return GetSmoothGradient(location.x(), location.y(), location.z(),\n nominal_window_size);\n }\n\n inline std::vector GetSmoothGradient4d(\n const Eigen::Vector4d& location,\n const double nominal_window_size) const\n {\n return GetSmoothGradient(location(0), location(1), location(2),\n nominal_window_size);\n }\n\n inline std::vector GetSmoothGradient(\n const double x, const double y, const double z,\n const double nominal_window_size) const\n {\n const double ideal_window_size = std::abs(nominal_window_size);\n if (LocationInBounds(x, y, z))\n {\n const double min_x = x - ideal_window_size;\n const double max_x = x + ideal_window_size;\n const double min_y = y - ideal_window_size;\n const double max_y = y + ideal_window_size;\n const double min_z = z - ideal_window_size;\n const double max_z = z + ideal_window_size;\n // Retrieve distance estimates\n const std::pair point_distance = EstimateDistance(x, y, z);\n const std::pair mx_distance = EstimateDistance(min_x, y, z);\n const std::pair px_distance = EstimateDistance(max_x, y, z);\n const std::pair my_distance = EstimateDistance(x, min_y, z);\n const std::pair py_distance = EstimateDistance(x, max_y, z);\n const std::pair mz_distance = EstimateDistance(x, y, min_z);\n const std::pair pz_distance = EstimateDistance(x, y, max_z);\n // Compute gradient for each axis\n const double gx = ComputeAxisSmoothGradient(point_distance,\n mx_distance,\n px_distance,\n x, min_x, max_x);\n const double gy = ComputeAxisSmoothGradient(point_distance,\n my_distance,\n py_distance,\n y, min_y, max_y);\n const double gz = ComputeAxisSmoothGradient(point_distance,\n mz_distance,\n pz_distance,\n z, min_z, max_z);\n return std::vector{gx, gy, gz};\n }\n else\n {\n return std::vector();\n }\n }\n\n inline std::vector GetSmoothGradient(\n const GRID_INDEX& index, const double nominal_window_size) const\n {\n return GetSmoothGradient4d(GridIndexToLocation(index), nominal_window_size);\n }\n\n inline std::vector GetSmoothGradient(\n const int64_t x_index, const int64_t y_index, const int64_t z_index,\n const double nominal_window_size) const\n {\n return GetSmoothGradient4d(\n GridIndexToLocation(x_index, y_index, z_index), nominal_window_size);\n }\n\n inline std::vector GetAutoDiffGradient3d(\n const Eigen::Vector3d& location) const\n {\n return GetAutoDiffGradient(location.x(), location.y(), location.z());\n }\n\n inline std::vector GetAutoDiffGradient4d(\n const Eigen::Vector4d& location) const\n {\n return GetAutoDiffGradient(location(0), location(1), location(2));\n }\n\n // TODO: this does not work if you query at cell centers!\n inline std::vector GetAutoDiffGradient(\n const double x, const double y, const double z) const\n {\n const GRID_INDEX index = LocationToGridIndex(x, y, z);\n if (IndexInBounds(index))\n {\n // Use with AutoDiffScalar\n typedef Eigen::AutoDiffScalar AScalar;\n typedef Eigen::Matrix APosition;\n APosition Alocation;\n Alocation(0) = x;\n Alocation(1) = y;\n Alocation(2) = z;\n Alocation(3) = 1.0;\n Alocation(0).derivatives() = Eigen::Vector4d::Unit(0);\n Alocation(1).derivatives() = Eigen::Vector4d::Unit(1);\n Alocation(2).derivatives() = Eigen::Vector4d::Unit(2);\n Alocation(3).derivatives() = Eigen::Vector4d::Unit(3);\n AScalar Adist = EstimateDistanceInterpolateFromNeighbors(\n Alocation, index.x, index.y, index.z);\n return std::vector{\n Adist.derivatives()(0), Adist.derivatives()(1), Adist.derivatives()(2)};\n }\n else\n {\n return std::vector();\n }\n }\n\n inline std::vector GetAutoDiffGradient(const GRID_INDEX& index) const\n {\n return GetAutoDiffGradient4d(GridIndexToLocation(index));\n }\n\n inline std::vector GetAutoDiffGradient(\n const int64_t x_index, const int64_t y_index, const int64_t z_index) const\n {\n return GetAutoDiffGradient4d(\n GridIndexToLocation(x_index, y_index, z_index));\n }\n\nprotected:\n\n inline double ComputeAxisSmoothGradient(\n const std::pair& query_point_distance_estimate,\n const std::pair& minus_axis_distance_estimate,\n const std::pair& plus_axis_distance_estimate,\n const double query_point_axis_value,\n const double minus_point_axis_value,\n const double plus_point_axis_value) const\n {\n if (query_point_distance_estimate.second\n && minus_axis_distance_estimate.second\n && plus_axis_distance_estimate.second)\n {\n const double window_size = plus_point_axis_value\n - minus_point_axis_value;\n const double distance_delta = plus_axis_distance_estimate.first\n - minus_axis_distance_estimate.first;\n return distance_delta / window_size;\n }\n else if (query_point_distance_estimate.second\n && minus_axis_distance_estimate.second)\n {\n const double window_size = query_point_axis_value\n - minus_point_axis_value;\n const double distance_delta = query_point_distance_estimate.first\n - minus_axis_distance_estimate.first;\n return distance_delta / window_size;\n }\n else if (query_point_distance_estimate.second\n && plus_axis_distance_estimate.second)\n {\n const double window_size = plus_point_axis_value\n - query_point_axis_value;\n const double distance_delta = plus_axis_distance_estimate.first\n - query_point_distance_estimate.first;\n return distance_delta / window_size;\n }\n else\n {\n throw std::runtime_error(\n \"Window size for GetSmoothGradient is too large for SDF\");\n }\n }\n\n template\n inline T BilinearInterpolate(const double low_d1,\n const double high_d1,\n const double low_d2,\n const double high_d2,\n const T query_d1,\n const T query_d2,\n const double l1l2_val,\n const double l1h2_val,\n const double h1l2_val,\n const double h1h2_val) const\n {\n Eigen::Matrix d1_offsets;\n d1_offsets(0, 0) = high_d1 - query_d1;\n d1_offsets(0, 1) = query_d1 - low_d1;\n Eigen::Matrix values;\n values(0, 0) = l1l2_val;\n values(0, 1) = l1h2_val;\n values(1, 0) = h1l2_val;\n values(1, 1) = h1h2_val;\n Eigen::Matrix d2_offsets;\n d2_offsets(0, 0) = high_d2 - query_d2;\n d2_offsets(1, 0) = query_d2 - low_d2;\n const T multiplier = 1.0 / ((high_d1 - low_d1) * (high_d2 - low_d2));\n const T bilinear_interpolated\n = multiplier * d1_offsets * values * d2_offsets;\n return bilinear_interpolated;\n }\n\n template\n inline T BilinearInterpolateDistanceXY(\n const Eigen::Vector4d& corner_location,\n const Eigen::Matrix& query_location,\n const double mxmy_dist, const double mxpy_dist,\n const double pxmy_dist, const double pxpy_dist) const\n {\n return BilinearInterpolate(corner_location(0),\n corner_location(0) + GetResolution(),\n corner_location(1),\n corner_location(1) + GetResolution(),\n query_location(0),\n query_location(1),\n mxmy_dist, mxpy_dist,\n pxmy_dist, pxpy_dist);\n }\n\n template\n inline T TrilinearInterpolateDistance(\n const Eigen::Vector4d& corner_location,\n const Eigen::Matrix& query_location,\n const double mxmymz_dist, const double mxmypz_dist,\n const double mxpymz_dist, const double mxpypz_dist,\n const double pxmymz_dist, const double pxmypz_dist,\n const double pxpymz_dist, const double pxpypz_dist) const\n {\n // Do bilinear interpolation in the lower XY plane\n const T mz_bilinear_interpolated\n = BilinearInterpolateDistanceXY(corner_location, query_location,\n mxmymz_dist, mxpymz_dist,\n pxmymz_dist, pxpymz_dist);\n // Do bilinear interpolation in the upper XY plane\n const T pz_bilinear_interpolated\n = BilinearInterpolateDistanceXY(corner_location, query_location,\n mxmypz_dist, mxpypz_dist,\n pxmypz_dist, pxpypz_dist);\n // Perform linear interpolation/extrapolation between lower and upper planes\n const double inv_resolution = 1.0 / GetResolution();\n const T distance_delta\n = pz_bilinear_interpolated - mz_bilinear_interpolated;\n const T distance_slope = distance_delta * inv_resolution;\n const T query_z_delta = query_location(2) - T(corner_location(2));\n return mz_bilinear_interpolated + (query_z_delta * distance_slope);\n }\n\n inline double GetCorrectedCenterDistance(const int64_t x_idx,\n const int64_t y_idx,\n const int64_t z_idx) const\n {\n const std::pair query\n = GetImmutable(x_idx, y_idx, z_idx);\n if (query.second)\n {\n const double nominal_sdf_distance = (double)query.first;\n const double cell_center_distance_offset = GetResolution() * 0.5;\n if (nominal_sdf_distance >= 0.0)\n {\n return nominal_sdf_distance - cell_center_distance_offset;\n }\n else\n {\n return nominal_sdf_distance + cell_center_distance_offset;\n }\n }\n else\n {\n throw std::invalid_argument(\"Index out of bounds\");\n }\n }\n\n template\n std::pair GetAxisInterpolationIndices(\n const int64_t initial_index,\n const int64_t axis_size,\n const T axis_offset) const\n {\n int64_t lower = initial_index;\n int64_t upper = initial_index;\n if (axis_offset >= 0.0)\n {\n upper = initial_index + 1;\n if (upper >= axis_size)\n {\n upper = initial_index;\n lower = initial_index -1;\n if (lower < 0)\n {\n lower = initial_index;\n }\n }\n }\n else\n {\n lower = initial_index - 1;\n if (lower < 0)\n {\n upper = initial_index + 1;\n lower = initial_index;\n if (upper >= axis_size)\n {\n upper = initial_index;\n }\n }\n }\n return std::make_pair(lower, upper);\n }\n\n template\n inline T EstimateDistanceInterpolateFromNeighbors(\n const Eigen::Matrix& query_location,\n const int64_t x_idx, const int64_t y_idx, const int64_t z_idx) const\n {\n // Get the query location in grid frame\n const Eigen::Matrix grid_frame_query_location\n = GetInverseOriginTransform() * query_location;\n // Switch between all the possible options of where we are\n const Eigen::Vector4d cell_center_location\n = GridIndexToLocationGridFrame(x_idx, y_idx, z_idx);\n const Eigen::Matrix query_offset\n = grid_frame_query_location - cell_center_location.cast();\n // Catch the easiest case\n// if ((query_offset(0) == 0.0)\n// && (query_offset(1) == 0.0)\n// && (query_offset(2) == 0.0))\n// {\n// return GetCorrectedCenterDistance(x_idx, y_idx, z_idx);\n// }\n // Find the best-matching 8 surrounding cell centers\n const std::pair x_axis_indices\n = GetAxisInterpolationIndices(x_idx, GetNumXCells(), query_offset(0));\n const std::pair y_axis_indices\n = GetAxisInterpolationIndices(y_idx, GetNumYCells(), query_offset(1));\n const std::pair z_axis_indices\n = GetAxisInterpolationIndices(z_idx, GetNumZCells(), query_offset(2));\n const Eigen::Vector4d lower_corner_location\n = GridIndexToLocationGridFrame(x_axis_indices.first,\n y_axis_indices.first,\n z_axis_indices.first);\n const double mxmymz_distance\n = GetCorrectedCenterDistance(x_axis_indices.first,\n y_axis_indices.first,\n z_axis_indices.first);\n const double mxmypz_distance\n = GetCorrectedCenterDistance(x_axis_indices.first,\n y_axis_indices.first,\n z_axis_indices.second);\n const double mxpymz_distance\n = GetCorrectedCenterDistance(x_axis_indices.first,\n y_axis_indices.second,\n z_axis_indices.first);\n const double mxpypz_distance\n = GetCorrectedCenterDistance(x_axis_indices.first,\n y_axis_indices.second,\n z_axis_indices.second);\n const double pxmymz_distance\n = GetCorrectedCenterDistance(x_axis_indices.second,\n y_axis_indices.first,\n z_axis_indices.first);\n const double pxmypz_distance\n = GetCorrectedCenterDistance(x_axis_indices.second,\n y_axis_indices.first,\n z_axis_indices.second);\n const double pxpymz_distance\n = GetCorrectedCenterDistance(x_axis_indices.second,\n y_axis_indices.second,\n z_axis_indices.first);\n const double pxpypz_distance\n = GetCorrectedCenterDistance(x_axis_indices.second,\n y_axis_indices.second,\n z_axis_indices.second);\n return TrilinearInterpolateDistance(lower_corner_location,\n grid_frame_query_location,\n mxmymz_distance, mxmypz_distance,\n mxpymz_distance, mxpypz_distance,\n pxmymz_distance, pxmypz_distance,\n pxpymz_distance, pxpypz_distance);\n }\n\npublic:\n\n inline std::pair EstimateDistance(const double x,\n const double y,\n const double z) const\n {\n return EstimateDistance4d(Eigen::Vector4d(x, y, z, 1.0));\n }\n\n inline std::pair EstimateDistance3d(\n const Eigen::Vector3d& location) const\n {\n const GRID_INDEX index = LocationToGridIndex3d(location);\n if (IndexInBounds(index))\n {\n return std::make_pair(\n EstimateDistanceInterpolateFromNeighbors(\n Eigen::Vector4d(location.x(), location.y(), location.z(), 1.0),\n index.x, index.y, index.z),\n true);\n }\n else\n {\n return std::make_pair((double)GetOOBValue(), false);\n }\n }\n\n inline std::pair EstimateDistance4d(\n const Eigen::Vector4d& location) const\n {\n const GRID_INDEX index = LocationToGridIndex4d(location);\n if (IndexInBounds(index))\n {\n return std::make_pair(EstimateDistanceInterpolateFromNeighbors(\n location, index.x, index.y, index.z),\n true);\n }\n else\n {\n return std::make_pair((double)GetOOBValue(), false);\n }\n }\n\n inline Eigen::Vector3d ProjectOutOfCollision(\n const double x, const double y, const double z,\n const double stepsize_multiplier = 1.0 / 10.0) const\n {\n const Eigen::Vector4d result\n = ProjectOutOfCollision4d(Eigen::Vector4d(x, y, z, 1.0),\n stepsize_multiplier);\n return result.head<3>();\n }\n\n inline Eigen::Vector3d ProjectOutOfCollision3d(\n const Eigen::Vector3d& location,\n const double stepsize_multiplier = 1.0 / 10.0) const\n {\n return ProjectOutOfCollision(location.x(), location.y(), location.z(),\n stepsize_multiplier);\n }\n\n inline Eigen::Vector4d ProjectOutOfCollision4d(\n const Eigen::Vector4d& location,\n const double stepsize_multiplier = 1.0 / 10.0) const\n {\n return ProjectOutOfCollisionToMinimumDistance4d(location, 0.0,\n stepsize_multiplier);\n }\n\n inline Eigen::Vector3d ProjectOutOfCollisionToMinimumDistance(\n const double x, const double y, const double z,\n const double minimum_distance,\n const double stepsize_multiplier = 1.0 / 10.0) const\n {\n return ProjectOutOfCollisionToMinimumDistance4d(\n Eigen::Vector4d(x, y, z, 1.0),\n minimum_distance, stepsize_multiplier).head<3>();\n }\n\n inline Eigen::Vector3d ProjectOutOfCollisionToMinimumDistance3d(\n const Eigen::Vector3d& location, const double minimum_distance,\n const double stepsize_multiplier = 1.0 / 10.0) const\n {\n return ProjectOutOfCollisionToMinimumDistance(\n location.x(), location.y(), location.z(),\n minimum_distance, stepsize_multiplier);\n }\n\n inline Eigen::Vector4d ProjectOutOfCollisionToMinimumDistance4d(\n const Eigen::Vector4d& location,\n const double minimum_distance,\n const double stepsize_multiplier = 1.0 / 10.0) const\n {\n // To avoid potential problems with alignment, we need to pass location\n // by reference, so we make a local copy here that we can change.\n // See https://eigen.tuxfamily.org/dox/group__TopicPassingByValue.html\n Eigen::Vector4d mutable_location = location;\n // If we are in bounds, start the projection process,\n // otherwise return the location unchanged\n if (LocationInBounds4d(mutable_location))\n {\n // Add a small collision margin to account for rounding and similar\n const double minimum_distance_with_margin\n = minimum_distance + GetResolution() * stepsize_multiplier * 1e-3;\n const double max_stepsize = GetResolution() * stepsize_multiplier;\n const bool enable_edge_gradients = true;\n double sdf_dist = EstimateDistance4d(mutable_location).first;\n while (sdf_dist <= minimum_distance)\n {\n const std::vector gradient\n = GetGradient4d(mutable_location, enable_edge_gradients);\n if (gradient.size() == 3)\n {\n const Eigen::Vector4d grad_vector(\n gradient[0], gradient[1], gradient[2], 0.0);\n if (grad_vector.norm() > GetResolution() * 0.25) // Sanity check\n {\n // Don't step any farther than is needed\n const double step_distance\n = std::min(max_stepsize,\n minimum_distance_with_margin - sdf_dist);\n mutable_location += grad_vector.normalized() * step_distance;\n sdf_dist = EstimateDistance4d(mutable_location).first;\n }\n else\n {\n throw std::runtime_error(\"Encountered flat gradient - stuck\");\n }\n }\n else\n {\n throw std::runtime_error(\"Failed to compute gradient - out of SDF?\");\n }\n }\n }\n return mutable_location;\n }\n\n static void SaveToFile(const SignedDistanceField& sdf,\n const std::string& filepath,\n const bool compress);\n\n static SignedDistanceField LoadFromFile(const std::string& filepath);\n\n static sdf_tools::SDF GetMessageRepresentation(\n const SignedDistanceField& sdf);\n\n static SignedDistanceField LoadFromMessageRepresentation(\n const sdf_tools::SDF& message);\n\n visualization_msgs::Marker ExportForDisplay(const float alpha = 0.01f) const;\n\n visualization_msgs::Marker ExportForDisplayCollisionOnly(\n const float alpha = 0.01f) const;\n\n /*\n * The following function can be *VERY EXPENSIVE* to compute, since it\n * performs gradient ascent/descent across the SDF\n */\n VoxelGrid ComputeLocalExtremaMap() const;\n};\n}\n\n#endif // SDF_HPP\n", "meta": {"hexsha": "81080f28e2cb3d3afea9fbe8b7bf7fb89d51682e", "size": 36955, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/sdf_tools/sdf.hpp", "max_stars_repo_name": "ToyotaResearchInstitute/sdf_tools", "max_stars_repo_head_hexsha": "781e4d5187c10b8235fcbd3fd6a5498c1fffa7aa", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/sdf_tools/sdf.hpp", "max_issues_repo_name": "ToyotaResearchInstitute/sdf_tools", "max_issues_repo_head_hexsha": "781e4d5187c10b8235fcbd3fd6a5498c1fffa7aa", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/sdf_tools/sdf.hpp", "max_forks_repo_name": "ToyotaResearchInstitute/sdf_tools", "max_forks_repo_head_hexsha": "781e4d5187c10b8235fcbd3fd6a5498c1fffa7aa", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0949667616, "max_line_length": 80, "alphanum_fraction": 0.5953727506, "num_tokens": 8361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646255, "lm_q2_score": 0.5, "lm_q1q2_score": 0.29821657313231276}} {"text": "#ifndef ALEPH_PERSISTENCE_DIAGRAMS_DISTANCES_BOTTLENECK_HH__\n#define ALEPH_PERSISTENCE_DIAGRAMS_DISTANCES_BOTTLENECK_HH__\n\n#include \n\n#include \n#include \n\n#include \n\n#include \n#include \n\nnamespace aleph\n{\n\nnamespace distances\n{\n\nnamespace detail\n{\n\ntemplate struct Edge\n{\n std::size_t source;\n std::size_t target;\n\n T weight;\n\n Edge( std::size_t s, std::size_t t, T w )\n : source( s )\n , target( t )\n , weight( w )\n {\n }\n\n bool operator<( const Edge& other ) const\n {\n return weight < other.weight;\n }\n};\n\ntemplate struct CheckMatchingCardinality\n{\n using GraphType = boost::adjacency_list;\n using MatchingVectorType = std::vector::vertex_descriptor>;\n\n CheckMatchingCardinality( std::size_t size, typename std::vector >::const_iterator begin )\n : _maximumSize( size )\n , _last( begin )\n , _graph( 2 * size )\n , _mates( 2 * size )\n {\n boost::add_edge( begin->source, begin->target, _graph );\n }\n\n bool operator()( typename std::vector >::const_iterator /* it1 */, typename std::vector >::const_iterator it2 )\n {\n // The new edge lies beyond the edges that are already known, so the\n // edges between the last edge and the new iterator position need to\n // be added.\n if( it2 > _last )\n {\n do\n {\n ++_last;\n boost::add_edge( _last->source, _last->target, _graph );\n }\n while( _last != it2 );\n }\n\n // The new edge lies behind the edges that are already known, so the\n // surplus edges need to be removed.\n else\n {\n do\n {\n boost::remove_edge( _last->source, _last->target, _graph );\n --_last;\n }\n while( _last != it2 );\n }\n\n boost::edmonds_maximum_cardinality_matching( _graph,\n &_mates[0] );\n\n // Look out for _perfect matchings_ in the bipartite graph. Any other\n // maximum cardinality matching does not qualify for the Bottleneck\n // distance.\n return boost::matching_size( _graph, &_mates[0] ) == _maximumSize;\n }\n\n std::size_t _maximumSize;\n\n typename std::vector >::const_iterator _last;\n\n GraphType _graph; // Input data\n MatchingVectorType _mates; // Edges of the matching\n};\n\n} // namespace detail\n\n/**\n Calculates the Bottleneck distance between two persistence diagrams.\n The algorithm used for this involves checking a (complete) bipartite\n graph for perfect matchings.\n\n A brief description of the algoritmh is given in\n\n Computational Topology\n Herbert Edelsbrunner and John Harer\n\n on page 191.\n\n The implementation has been inspired by Dmitriy Morozov's \"Dionysus\"\n framework.\n\n @param D1 First persistence diagram\n @param D2 Second persistence diagram\n\n @returns Bottleneck distance between the two persistence diagrams\n*/\n\n\ntemplate <\n class DataType,\n class Distance = aleph::geometry::distances::InfinityDistance\n> DataType bottleneckDistance( const PersistenceDiagram& D1,\n const PersistenceDiagram& D2 )\n{\n auto n = D1.size();\n auto m = D2.size();\n auto maximumSize = n + m;\n\n using SizeType = decltype(n);\n using Edge = detail::Edge;\n\n std::vector edges;\n\n // Diagonal edges ----------------------------------------------------\n\n for( SizeType i = n; i < maximumSize; i++ )\n for( SizeType j = maximumSize + i; j < 2 * maximumSize; j++ )\n edges.push_back( Edge( static_cast(i), static_cast(j), DataType() ) );\n\n SizeType i = 0;\n\n // Edges between regular points --------------------------------------\n\n Distance distance;\n\n for( auto it1 = D1.begin(); it1 != D1.end(); ++it1 )\n {\n auto j = maximumSize;\n\n for( auto it2 = D2.begin(); it2 != D2.end(); ++it2 )\n {\n auto weight = distance( *it1, *it2 );\n\n edges.push_back( Edge( static_cast(i), static_cast(j),\n weight ) );\n\n ++j;\n }\n\n ++i;\n }\n\n // Edges between points and their projections ------------------------\n\n i = 0;\n\n for( auto it1 = D1.begin(); it1 != D1.end(); ++it1 )\n {\n edges.push_back( Edge( static_cast(i), static_cast(maximumSize + m + i),\n aleph::distances::detail::orthogonalDistance( *it1 ) ) );\n\n ++i;\n }\n\n i = maximumSize;\n\n for( auto it2 = D2.begin(); it2 != D2.end(); ++it2 )\n {\n edges.push_back( Edge( static_cast(n + i - maximumSize), static_cast(i),\n aleph::distances::detail::orthogonalDistance( *it2 ) ) );\n }\n\n // Identify matchings ------------------------------------------------\n\n std::sort( edges.begin(), edges.end() );\n\n // Perform binary search over edge sets. Starting from the empty graph, use\n // more and more edges to find out the first graph that permits a maximum\n // cardinality matching.\n\n using EdgeIteratorType = typename std::vector::const_iterator;\n using CountingIteratorType = boost::counting_iterator;\n\n auto itEdge = std::upper_bound( CountingIteratorType( edges.begin() ),\n CountingIteratorType( edges.end() ),\n edges.begin(),\n detail::CheckMatchingCardinality( maximumSize, edges.begin() ) );\n\n return (*itEdge)->weight;\n}\n\n} // namespace distances\n\n} // namespace aleph\n\n#endif\n", "meta": {"hexsha": "69deeccfa49c30ccb8f34ff9222a08f63c28e09d", "size": 5855, "ext": "hh", "lang": "C++", "max_stars_repo_path": "include/aleph/persistenceDiagrams/distances/Bottleneck.hh", "max_stars_repo_name": "eudoxos/Aleph", "max_stars_repo_head_hexsha": "874882c33a0e8429c74e567eb01525613fee0616", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 56.0, "max_stars_repo_stars_event_min_datetime": "2019-04-24T22:11:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T11:37:47.000Z", "max_issues_repo_path": "include/aleph/persistenceDiagrams/distances/Bottleneck.hh", "max_issues_repo_name": "eudoxos/Aleph", "max_issues_repo_head_hexsha": "874882c33a0e8429c74e567eb01525613fee0616", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 48.0, "max_issues_repo_issues_event_min_datetime": "2016-11-30T09:37:13.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-30T21:43:39.000Z", "max_forks_repo_path": "include/aleph/persistenceDiagrams/distances/Bottleneck.hh", "max_forks_repo_name": "eudoxos/Aleph", "max_forks_repo_head_hexsha": "874882c33a0e8429c74e567eb01525613fee0616", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2019-05-02T11:54:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-10T14:05:40.000Z", "avg_line_length": 27.4882629108, "max_line_length": 129, "alphanum_fraction": 0.6227156277, "num_tokens": 1462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331462646254, "lm_q2_score": 0.5, "lm_q1q2_score": 0.2982165731323127}} {"text": "#include \"geom/Vector2D.hpp\"\n#include \"geom/Transform.hpp\"\n#include \"geom/BoundingBox.hpp\"\n#include \"geom/Math.hpp\"\n#include \"geom/CollisionCheck.hpp\"\n\n#include \n\n\nvoid export_geom()\n{\n namespace bp = boost::python;\n namespace ag = avs::geom;\n\n // Make from avsimpy.geometrics import ... work\n bp::object utilModule(bp::handle<>(bp::borrowed(PyImport_AddModule(\"avsimpy.geometrics\"))));\n // Make from avsimpy import geometrics work\n bp::scope().attr(\"geometrics\") = utilModule;\n bp::scope util_scope = utilModule;\n\n\n bp::class_(\"Vector2D\")\n .def(bp::init((bp::arg(\"x\")=0.0f, bp::arg(\"y\")=0.0f)))\n .def(bp::init((bp::arg(\"vector\"))))\n .def_readwrite(\"x\", &ag::Vector2D::x)\n .def_readwrite(\"y\", &ag::Vector2D::y)\n .def(\"get_length\", &ag::Vector2D::get_length)\n .def(\"get_unit_vector\", &ag::Vector2D::get_unit_vector)\n .def(\"__eq__\", &ag::Vector2D::operator==)\n .def(\"__ne__\", &ag::Vector2D::operator!=)\n .def(bp::self += bp::self)\n .def(bp::self + bp::self)\n .def(bp::self -= bp::self)\n .def(bp::self - bp::self)\n .def(bp::self *= double())\n .def(bp::self * double())\n .def(double() * bp::self)\n .def(bp::self /= double())\n .def(bp::self / double())\n .def(double() / bp::self)\n .def(bp::self_ns::str(bp::self_ns::self))\n ;\n\n bp::class_(\"Transform\")\n .def(bp::init(\n (bp::arg(\"location\")=ag::Vector2D(), bp::arg(\"rotation\")=0.0f)))\n .def(bp::init((bp::arg(\"transform\"))))\n .def_readwrite(\"location\", &ag::Transform::location)\n .def_readwrite(\"rotation\", &ag::Transform::rotation)\n .def(\"get_forward_vector\", &ag::Transform::get_forward_vector)\n .def(\"calculate_distance\", &ag::Transform::calculate_distance)\n .def(\"__eq__\", &ag::Transform::operator==)\n .def(\"__ne__\", &ag::Transform::operator!=)\n .def(bp::self_ns::str(bp::self_ns::self))\n ;\n\n bp::class_(\"BoundingBox\")\n .def(bp::init(\n (bp::arg(\"location\")=ag::Vector2D(), bp::arg(\"extent\")=ag::Vector2D())))\n .def(bp::init(\n (bp::arg(\"x\")=0.0f, bp::arg(\"y\")=0.0f, bp::arg(\"extent_x\")=1.0f, bp::arg(\"extent_y\")=1.0f)))\n .def(bp::init((bp::arg(\"bounding_box\"))))\n .def_readwrite(\"location\", &ag::BoundingBox::center)\n .def_readwrite(\"extent\", &ag::BoundingBox::extent)\n .def(\"contains\", &ag::BoundingBox::contains, bp::arg(\"point\"))\n .def(\"intersects\", &ag::BoundingBox::intersects, bp::arg(\"bounding_box\"))\n .def(\"__eq__\", &ag::BoundingBox::operator==)\n .def(\"__ne__\", &ag::BoundingBox::operator!=)\n .def(bp::self_ns::str(bp::self_ns::self))\n ;\n\n bp::class_(\"math\")\n .def(\"to_radian\", &ag::Math::to_radian, bp::arg(\"deg\"))\n .def(\"to_degree\", &ag::Math::to_degree, bp::arg(\"rad\"))\n .def(\"dot_product\", &ag::Math::dot_product, (bp::arg(\"vector_A\"), bp::arg(\"vector_B\")))\n .def(\"calculate_distance\", &ag::Math::calculate_distance, (bp::arg(\"vector_A\"), bp::arg(\"vector_B\")))\n .def(\"calculate_angle\", &ag::Math::calculate_angle, (bp::arg(\"vector_A\"), bp::arg(\"vector_B\")))\n .def(\"get_forward_vector\", &ag::Math::get_forward_vector, bp::arg(\"deg\"))\n .def(\"rotate_vector_on_origin\", &ag::Math::rotate_vector_on_origin, (bp::arg(\"vector\"), bp::arg(\"deg\")))\n .def(\"rotate_vector_on_point\", &ag::Math::rotate_vector_on_point, (bp::arg(\"vector\"), bp::arg(\"deg\"), bp::arg(\"point\")))\n ;\n\n bp::class_(\"CollisionChecker\")\n .def(\"check_collision\", &ag::CollisionChecker::check_collision, (bp::arg(\"entity_A\"), bp::arg(\"entity_B\")))\n .def(bp::self_ns::str(bp::self_ns::self))\n ;\n\n}\n", "meta": {"hexsha": "4359634b9ebcfd4c58bc67018e3de2fe2a2f2585", "size": 4047, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "PythonAPI/Geom.cpp", "max_stars_repo_name": "50sven/avsim", "max_stars_repo_head_hexsha": "bfd29c8f0fe10a4f279310ded9b97aee6fab8819", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "PythonAPI/Geom.cpp", "max_issues_repo_name": "50sven/avsim", "max_issues_repo_head_hexsha": "bfd29c8f0fe10a4f279310ded9b97aee6fab8819", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PythonAPI/Geom.cpp", "max_forks_repo_name": "50sven/avsim", "max_forks_repo_head_hexsha": "bfd29c8f0fe10a4f279310ded9b97aee6fab8819", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.4719101124, "max_line_length": 128, "alphanum_fraction": 0.5972325179, "num_tokens": 1184, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.5964331319177487, "lm_q2_score": 0.5, "lm_q1q2_score": 0.29821656595887436}} {"text": "//------------------------------------------------------------------------------\n// © 2021. Triad National Security, LLC. All rights reserved. This\n// program was produced under U.S. Government contract 89233218CNA000001\n// for Los Alamos National Laboratory (LANL), which is operated by Triad\n// National Security, LLC for the U.S. Department of Energy/National\n// Nuclear Security Administration. All rights in the program are\n// reserved by Triad National Security, LLC, and the U.S. Department of\n// Energy/National Nuclear Security Administration. The Government is\n// granted for itself and others acting on its behalf a nonexclusive,\n// paid-up, irrevocable worldwide license in this material to reproduce,\n// prepare derivative works, distribute copies to the public, perform\n// publicly and display publicly, and to permit others to do so.\n//------------------------------------------------------------------------------\n\n#ifndef _SINGULARITY_EOS_CLOSURE_MIXED_CELL_MODELS_\n#define _SINGULARITY_EOS_CLOSURE_MIXED_CELL_MODELS_\n\n#include \n#include \n\n#include \n\n#ifdef SINGULARITY_USE_KOKKOSKERNELS\n#include \n#include \n#include \n#else\n#include \n#endif // SINGULARITY_USE_KOKKOSKERNELS\n\nnamespace singularity {\n\n/*\n This is the PTE code based on FLAG's matrix form in their mixgas treatment\n I have modified it to include a line search which improves robustness and\n quality of non-converged solutions, at the likely cost of speed (due to\n additional EOS calls).\n It is templated on nmat and takes an array of Indexers to the EOSs,\n Volume (total volume of materials to be equilibrated), total SIE,\n and an array of masses of each component as inputs, and returns component\n volumes and energies (SIEs) as output.\n\n EOSIndexer must have an operator[](int) that returns an EOS. e.g., EOS*\n RealIndexer must have an operator[](int) that returns a Real. e.g., Real*\n ConstRealIndexer is as RealIndexer, but assumed const type.\n LambdaIndexer must have an operator[](int) that returns a Real*. e.g., Real**\n*/\n// Version templated on nmat\n// niter version produces histogram\ntemplate \nPORTABLE_INLINE_FUNCTION bool pte_closure_flag_with_line(\n EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &niter);\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag_with_line(EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses,\n RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas) {\n int niter;\n return pte_closure_flag_with_line(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas, niter);\n}\n// Version with nmat available at runtime\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag(int nmat, EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &niter);\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag(int nmat, EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas) {\n int niter;\n return pte_closure_flag(nmat, eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n}\n// Pointer-only version with offset for EOS indexing\nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag_offset(int nmat, EOS *eoss, const Real Volume, const Real TotalSIE,\n int const *const ComponentMats, const Real *ComponentMasses,\n Real *ComponentVolumes, Real *ComponentEnergies, Real **lambdas,\n int &niter);\nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag_offset(int nmat, EOS *eoss, const Real Volume, const Real TotalSIE,\n int const *const ComponentMats, const Real *ComponentMasses,\n Real *ComponentVolumes, Real *ComponentEnergies, Real **lambdas) {\n int niter;\n return pte_closure_flag_offset(nmat, eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes, ComponentEnergies,\n lambdas, niter);\n}\n/*\n This solver was developed by Josh Dolence, and is guaranteed to\n return a state where energies and volume fractions add up to the\n total energy and 1 respectively, even if the solve fails.\n\n EOSIndexer must have an operator[](int) that returns an EOS. e.g., EOS*\n RealIndexer must have an operator[](int) that returns a Real. e.g., Real*\n LambdaIndexer must have an operator[](int) that returns a Real*. e.g., Real**\n*/\n// Version templated on nmat.\ntemplate \nPORTABLE_INLINE_FUNCTION bool pte_closure_josh(EOSIndexer &&eos, const Real vfrac_tot,\n const Real sie_tot, RealIndexer &&rho,\n RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press,\n LambdaIndexer &&lambda, int &niter);\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh(EOSIndexer &&eos, const Real vfrac_tot, const Real sie_tot,\n RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press, LambdaIndexer &&lambda) {\n int niter;\n return pte_closure_josh(eos, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press, lambda,\n niter);\n}\n// Version with nmat available at runtime.\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh(int nmat, EOSIndexer &&eoss, const Real vfrac_tot, const Real sie_tot,\n RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press, LambdaIndexer &&lambdas,\n int &niter);\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh(int nmat, EOSIndexer &&eoss, const Real vfrac_tot, const Real sie_tot,\n RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press, LambdaIndexer &&lambdas) {\n int niter;\n return pte_closure_josh(nmat, eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n}\n// Pointer-only version with offset for EOS indexing\nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh_offset(int nmat, EOS *eoss, const Real vfrac_tot, const Real sie_tot,\n int const *const Mats, Real *rho, Real *vfrac, Real *sie,\n Real *temp, Real *press, Real **lambdas, int &niter);\nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh_offset(int nmat, EOS *eoss, const Real vfrac_tot, const Real sie_tot,\n int const *const Mats, Real *rho, Real *vfrac, Real *sie,\n Real *temp, Real *press, Real **lambdas) {\n int niter;\n return pte_closure_josh_offset(nmat, eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n}\n\n/*\n This is a formulation of the PTE closure equations which tries to minimize\n differences between T and P/T. Since T (should be) positive definite, this\n should be well-founded. In mixtures of ideal gasses, this should be linear\n (so for hot plasmas, this should be linear-ish).\n Equations 1-nmat will be:\n T1-T0 = 0, T2-T1=0, [...], Tnmat-Tnmatm1=0, sum(Ei) = Etot\n and Equations nmat+1-2*nmat will be:\n P1/T1-P0/T0 = 0, P2/T2-P1/T1 = 0 [...], Sum(volumes)=Volume\n\n EOSIndexer must have an operator[](int) that returns an EOS. e.g., EOS*\n RealIndexer must have an operator[](int) that returns a Real. e.g., Real*\n ConstRealIndexer is as RealIndexer, but assumed const type.\n LambdaIndexer must have an operator[](int) that returns a Real*. e.g., Real**\n*/\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_ideal(int nmat, EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &niter);\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_ideal(int nmat, EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas) {\n int niter;\n return pte_closure_ideal(nmat, eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas, niter);\n}\n\n// ======================================================================\n// Implementation details below\n// ======================================================================\n\nnamespace mix_params {\nconstexpr Real derivative_eps = 3.0e-6;\nconstexpr Real pte_rel_tolerance_p = 1.e-4;\nconstexpr Real pte_rel_tolerance_t = 1.e-4;\nconstexpr Real pte_abs_tolerance_p = 0.0;\nconstexpr Real pte_abs_tolerance_t = 0.0;\nconstexpr int pte_max_iter_per_mat = 16;\nconstexpr Real line_search_alpha = 1.e-4;\nconstexpr int line_search_max_iter = 3;\nconstexpr Real line_search_fac = 0.05;\n} // namespace mix_params\n\nnamespace mix_impl {\ntemplate ::value>::type>\nconstexpr bool isfinite(const T &a) {\n return (a == a) && ((a == 0) || (a != 2 * a));\n}\n\nconstexpr Real square(const Real x) { return x * x; }\n\nPORTABLE_INLINE_FUNCTION\nbool check_nans(Real const *const a, const int n, const bool verbose = false) {\n bool retval = true;\n for (int i = 0; i < n; ++i)\n if (!isfinite(a[i])) {\n retval = false;\n#ifndef KOKKOS_ENABLE_CUDA\n if (verbose) {\n printf(\"bad val in element %i/%i\\n\", i, n);\n }\n#endif // KOKKOS_ENABLE_CUDA\n }\n return retval;\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool solve_Ax_b(Real *a, Real *b) {\n#ifdef SINGULARITY_USE_KOKKOSKERNELS\n#ifndef PORTABILITY_STRATEGY_KOKKOS\n#error \"Kokkos Kernels requires Kokkos.\"\n#endif\n Real t_[n], w_[n];\n // aliases for kokkos views\n using Unmgd = Kokkos::MemoryTraits;\n using Lrgt = Kokkos::LayoutRight;\n using vec_t = Kokkos::View;\n // aliases for QR solve template params\n using QR_alg = KokkosBatched::Algo::QR::Unblocked;\n using Lft = KokkosBatched::Side::Left;\n using Trs = KokkosBatched::Trans::Transpose;\n using nTrs = KokkosBatched::Trans::NoTranspose;\n using ApQ_alg = KokkosBatched::Algo::ApplyQ::Unblocked;\n using UP = KokkosBatched::Uplo::Upper;\n using NonU = KokkosBatched::Diag::NonUnit;\n using Tr_alg = KokkosBatched::Algo::Trsv::Unblocked;\n // aliases for solver structs ('invoke' member of the struct is the\n // actual function call)\n using QR_factor = KokkosBatched::SerialQR;\n using ApplyQ_transpose = KokkosBatched::SerialApplyQ;\n using InvertR = KokkosBatched::SerialTrsv;\n // view of matrix\n Kokkos::View A(a, n, n);\n // view of RHS\n vec_t B(b, n);\n // view of reflectors\n vec_t t(t_, n);\n // view of workspace\n vec_t w(w_, n);\n // QR factor A, A x = B -> Q R x = B\n // store result in A and t\n QR_factor::invoke(A, t, w);\n // Apply Q^T from the left to both sides\n // Q^T Q R x = Q^T B -> R x = Q^T B\n // store result of Q^T B in B\n ApplyQ_transpose::invoke(A, t, B, w);\n // Apply R^-1 from the left to both sides\n // R^-1 R x = R^-1 Q^T B -> x = R^-1 Q^T B\n // store solution vector x in B\n InvertR::invoke(1.0, A, B);\n#else\n#ifdef PORTABILITY_STRATEGY_KOKKOS\n#error \"Eigen should not be used with Kokkos.\"\n#endif\n // Eigen VERSION\n Eigen::Map> A(a);\n Eigen::Map> B(b);\n Eigen::Matrix X;\n X = A.lu().solve(B);\n B = X;\n#endif // SINGULARITY_USE_KOKKOSKERNELS\n bool retval = check_nans(b, n);\n return retval;\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag_with_line_impl(EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses,\n RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas,\n const OFFSETTER ofst, int &iter) {\n using namespace mix_params;\n\n Real TotalMass = 0.0, Vsum = 0.0, Esum = 0.0;\n Real Densities[nmat], Pressures[nmat], Temperatures[nmat], dpdr[nmat];\n Real dpde[nmat], dtdr[nmat], dtde[nmat], b[2 * nmat], A[4 * nmat * nmat];\n Real rtemp[nmat], sietemp[nmat];\n // First, normalize the energies and volumes.\n // This may or may not be close to reality since SIE isn't strictly positive.\n for (int i = 0; i < nmat; ++i)\n TotalMass += ComponentMasses[i];\n bool iszero = true;\n for (int i = 0; i < nmat; ++i)\n iszero &= ComponentVolumes[i] <= 1.0e-16;\n if (iszero)\n for (int i = 0; i < nmat; ++i)\n ComponentVolumes[i] = Volume * ComponentMasses[i] / TotalMass;\n for (int i = 0; i < nmat; ++i)\n Vsum += ComponentVolumes[i];\n for (int i = 0; i < nmat; ++i)\n ComponentVolumes[i] *=\n Volume / Vsum; // Are compilers smart enough to calculate this RHS once?\n for (int i = 0; i < nmat; ++i)\n Esum += ComponentEnergies[i] * ComponentMasses[i];\n if (std::abs(Esum) <\n 0.0001) { // Then we punt and just distribute based on mass fractions\n for (int i = 0; i < nmat; ++i)\n ComponentEnergies[i] = TotalSIE * TotalMass / ComponentMasses[i];\n } else { // Otherwise, we scale\n for (int i = 0; i < nmat; ++i)\n ComponentEnergies[i] *= (TotalSIE * TotalMass / Esum);\n }\n\n // This is the main loop\n constexpr const int pte_max_iter = nmat * pte_max_iter_per_mat;\n for (iter = 0; iter < pte_max_iter; ++iter) {\n // Call the EOSs\n for (int mat = 0; mat < nmat; ++mat) {\n Densities[mat] = ComponentMasses[mat] / ComponentVolumes[mat];\n eoss[ofst(mat)].PTofRE(Densities[mat], ComponentEnergies[mat], lambdas[mat],\n Pressures[mat], Temperatures[mat], dpdr[mat], dpde[mat],\n dtdr[mat], dtde[mat]);\n }\n // Now, zero the matrix and vector\n for (int i = 0; i < 2 * nmat * 2 * nmat; ++i)\n A[i] = 0.0;\n for (int i = 0; i < 2 * nmat; ++i)\n b[i] = 0.0;\n // print_matrix(2*nmat,2*nmat,A);\n // print_vector(2*nmat,b);\n Real vsum = 0.0;\n Real esum = 0.0;\n Real err = 0.0;\n // build matrix and vector\n for (int n = 0; n < nmat - 1; ++n) {\n const int i = n + nmat;\n // First, do the energy side\n A[n * 2 * nmat + n] = dtde[n];\n A[n * 2 * nmat + n + 1] = -dtde[n + 1];\n A[n * 2 * nmat + i] = dtdr[n];\n A[n * 2 * nmat + i + 1] = -dtdr[n + 1];\n A[(nmat - 1) * 2 * nmat + n] = ComponentMasses[n];\n b[n] = Temperatures[n + 1] - Temperatures[n];\n esum += ComponentMasses[n] * ComponentEnergies[n];\n // Now the density half\n A[i * 2 * nmat + n] = dpde[n];\n A[i * 2 * nmat + n + 1] = -dpde[n + 1];\n A[i * 2 * nmat + i] = dpdr[n];\n A[i * 2 * nmat + i + 1] = -dpdr[n + 1];\n A[(2 * nmat - 1) * 2 * nmat + i] = ComponentMasses[n] / square(Densities[n]);\n b[i] = Pressures[n + 1] - Pressures[n];\n vsum += ComponentMasses[n] / Densities[n];\n }\n A[(nmat - 1) * 2 * nmat + nmat - 1] = ComponentMasses[nmat - 1];\n esum += ComponentMasses[nmat - 1] * ComponentEnergies[nmat - 1];\n b[nmat - 1] = TotalSIE * TotalMass - esum; // esum - TotalSIE*TotalMass;\n A[4 * nmat * nmat - 1] = ComponentMasses[nmat - 1] / square(Densities[nmat - 1]);\n vsum += ComponentMasses[nmat - 1] / Densities[nmat - 1];\n b[2 * nmat - 1] = vsum - Volume;\n for (int i = 0; i < 2 * nmat; ++i)\n err += square(b[i]);\n err *= 0.5;\n if (!solve_Ax_b<2 * nmat>(A, b)) {\n // do something to crash out? Tell folks what happened?\n#ifndef KOKKOS_ENABLE_CUDA\n printf(\"Crashing out on iteration %i\\n\", iter);\n#endif // KOKKOS_ENABLE_CUDA\n break;\n }\n // LINE SEARCH\n\n // Now, get overall scaling limit\n Real scale = 1.0;\n for (int m = 0; m < nmat; ++m) {\n Real rt = Densities[m] + scale * b[m + nmat];\n if (rt < 0.0) {\n scale = -0.9 * Densities[m] / b[m + nmat];\n }\n const Real dt = (dtdr[m] * b[m + nmat] + dtde[m] * b[m]);\n const Real tt = Temperatures[m] + scale * dt;\n if (tt < 0.0) scale = -0.9 * Temperatures[m] / dt;\n }\n // Now apply the overall pre-scaling\n for (int i = 0; i < 2 * nmat; ++i)\n b[i] *= scale;\n // Line search\n Real gradfdx = -2.0 * scale * err;\n scale = 1.0;\n Real err_old = err;\n int line_iter = 0;\n Real err_p, err_t;\n do {\n for (int m = 0; m < nmat; ++m) {\n rtemp[m] = Densities[m] + scale * b[m + nmat];\n sietemp[m] = ComponentEnergies[m] + scale * b[m];\n Temperatures[m] = eoss[ofst(m)].TemperatureFromDensityInternalEnergy(\n rtemp[m], sietemp[m], lambdas[m]);\n if (eoss[ofst(m)].PreferredInput() ==\n (thermalqs::density | thermalqs::specific_internal_energy)) {\n Pressures[m] = eoss[ofst(m)].PressureFromDensityInternalEnergy(\n rtemp[m], sietemp[m], lambdas[m]);\n } else if (eoss[ofst(m)].PreferredInput() ==\n (thermalqs::density | thermalqs::temperature)) {\n Pressures[m] = eoss[ofst(m)].PressureFromDensityTemperature(\n rtemp[m], Temperatures[m], lambdas[m]);\n }\n }\n err_p = 0.0;\n err_t = 0.0;\n for (int n = 0; n < nmat - 1; ++n) {\n err_p += square(Pressures[n + 1] - Pressures[n]);\n err_t += square(Temperatures[n + 1] - Temperatures[n]);\n }\n err = 0.5 * (err_p + err_t);\n line_iter++;\n if (line_iter > line_search_max_iter ||\n err < err_old + line_search_alpha * scale * gradfdx)\n break;\n scale *= line_search_fac;\n } while (true);\n\n // END LINE SEARCH\n\n Real mean_p = 0, mean_t = 0;\n\n for (int i = 0; i < 2 * nmat; ++i)\n b[i] *= scale;\n for (int n = 0; n < nmat; ++n) {\n const int i = nmat + n;\n ComponentEnergies[n] += b[n];\n Densities[n] += b[i];\n ComponentVolumes[n] = ComponentMasses[n] / Densities[n];\n mean_p += ComponentVolumes[n] * Pressures[n];\n mean_t += ComponentMasses[n] * Temperatures[n];\n }\n mean_p /= Volume;\n mean_t /= TotalMass;\n err_p = std::sqrt(err_p);\n err_t = std::sqrt(err_t);\n bool converged_p =\n (err_p < pte_rel_tolerance_p * std::abs(mean_p) || err_p < pte_abs_tolerance_p);\n bool converged_t =\n (err_t < pte_rel_tolerance_t * std::abs(mean_t) || err_t < pte_abs_tolerance_t);\n if (converged_p && converged_t) {\n return true; // FIXME\n }\n }\n return false; // FIXME\n}\n\n// RealIndexer types may be different because some might be arrays and\n// some might be pointers.\ntemplate \nPORTABLE_INLINE_FUNCTION static void pte_residual(const Real utot, T1 &&vfrac, Real *u,\n T2 &&temp, T3 &&press, Real *residual) {\n Real vsum = 0.0;\n Real esum = 0.0;\n for (int m = 0; m < nmat; ++m) {\n vsum += vfrac[m];\n esum += u[m];\n }\n residual[0] = 1.0 - vsum;\n residual[1] = utot - esum;\n for (int m = 0; m < nmat - 1; ++m) {\n residual[2 + m] = press[m + 1] - press[m];\n residual[1 + nmat + m] = temp[m + 1] - temp[m];\n }\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh_impl(EOSIndexer &&eos, const Real vfrac_tot, const Real sie_tot,\n RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press, LambdaIndexer &&lambda,\n const OFFSETTER ofst, int &niter) {\n using namespace mix_params;\n const Real ilog2 = 1.0 / std::log(2.0);\n Real vsum = 0.0;\n // Normalize vfrac\n for (int m = 0; m < nmat; ++m)\n vsum += vfrac[m];\n for (int m = 0; m < nmat; ++m)\n vfrac[m] /= vsum;\n Real rhobar[nmat]; // This is a fixed quantity: the average density of\n // material m averaged over the full PTE volume\n for (int m = 0; m < nmat; ++m)\n rhobar[m] = rho[m] * vfrac[m];\n Real rho_total = 0.0;\n for (int m = 0; m < nmat; ++m)\n rho_total += rhobar[m];\n // Renormalize energies as well\n Real utot = rho_total * sie_tot;\n Real u[nmat];\n Real esum = 0.0;\n for (int m = 0; m < nmat; ++m)\n u[m] = sie[m] * rhobar[m];\n for (int m = 0; m < nmat; ++m)\n esum += u[m];\n for (int m = 0; m < nmat; ++m)\n u[m] *= utot / esum;\n Real jacobian[4 * nmat * nmat];\n Real dx[2 * nmat];\n Real residual[2 * nmat];\n Real Cache[nmat][MAX_NUM_LAMBDAS];\n // Real* Cache[nmat];\n // for (int m {0}; m < nmat; ++m) Cache[m] = nullptr;\n Real vtemp[nmat], rtemp[nmat], utemp[nmat];\n\n Real dpde[nmat], dtde[nmat], dpdv[nmat], dtdv[nmat];\n\n // set some options and make the initial EOS calls\n enum class EosPreference { RhoT, Rhoe };\n EosPreference eos_choice[nmat];\n for (int m = 0; m < nmat; m++) {\n temp[m] = eos[ofst(m)].TemperatureFromDensityInternalEnergy(rho[m], sie[m], Cache[m]);\n if (eos[ofst(m)].PreferredInput() ==\n (thermalqs::density | thermalqs::specific_internal_energy)) {\n eos_choice[m] = EosPreference::Rhoe;\n press[m] = eos[ofst(m)].PressureFromDensityInternalEnergy(rho[m], sie[m], Cache[m]);\n } else if (eos[ofst(m)].PreferredInput() ==\n (thermalqs::density | thermalqs::temperature)) {\n eos_choice[m] = EosPreference::RhoT;\n press[m] = eos[ofst(m)].PressureFromDensityTemperature(rho[m], temp[m], Cache[m]);\n }\n }\n\n bool converged_p = false;\n bool converged_t = false;\n bool converged = true;\n niter = 0;\n constexpr const int pte_max_iter = nmat * pte_max_iter_per_mat;\n for (niter = 0; niter < pte_max_iter; ++niter) {\n for (int m = 0; m < nmat; m++) {\n //////////////////////////////\n // perturb volume fractions\n //////////////////////////////\n const Real deriv_mult = vfrac[m] > 0.01 ? vfrac[m] : 0.01;\n const Real ldv = std::log(derivative_eps * deriv_mult) * ilog2;\n Real dv = std::pow(2.0, std::round(ldv));\n dv *= (vfrac[m] < 0.5 ? 1.0 : -1.0);\n const Real vf_pert = vfrac[m] + dv;\n const Real rho_pert = rhobar[m] / vf_pert;\n\n Real p_pert;\n Real t_pert =\n eos[ofst(m)].TemperatureFromDensityInternalEnergy(rho_pert, sie[m], Cache[m]);\n switch (eos_choice[m]) {\n case EosPreference::Rhoe:\n p_pert =\n eos[ofst(m)].PressureFromDensityInternalEnergy(rho_pert, sie[m], Cache[m]);\n break;\n case EosPreference::RhoT:\n p_pert = eos[ofst(m)].PressureFromDensityTemperature(rho_pert, t_pert, Cache[m]);\n break;\n }\n dpdv[m] = (p_pert - press[m]) / dv;\n dtdv[m] = (t_pert - temp[m]) / dv;\n //////////////////////////////\n // perturb energies\n //////////////////////////////\n Real lde = std::log(derivative_eps * std::abs(u[m])) * ilog2;\n const Real de = std::pow(2.0, std::round(lde));\n Real e_pert = (u[m] + de) / rhobar[m];\n\n t_pert =\n eos[ofst(m)].TemperatureFromDensityInternalEnergy(rho[m], e_pert, Cache[m]);\n switch (eos_choice[m]) {\n case EosPreference::Rhoe:\n p_pert = eos[ofst(m)].PressureFromDensityInternalEnergy(rho[m], e_pert, Cache[m]);\n break;\n case EosPreference::RhoT:\n p_pert = eos[ofst(m)].PressureFromDensityTemperature(rho[m], t_pert, Cache[m]);\n break;\n }\n dpde[m] = (p_pert - press[m]) / de;\n dtde[m] = (t_pert - temp[m]) / de;\n if (std::abs(dtde[m]) < 1.e-16) { // must be on the cold curve\n dtde[m] = derivative_eps;\n ;\n }\n }\n // Fill in the residual\n pte_residual(utot, vfrac, u, temp, press, residual);\n Real err = 0;\n for (int i = 0; i < 2 * nmat; ++i)\n err += residual[i] * residual[i];\n err *= 0.5;\n // Fill in the Jacobian\n for (int i = 0; i < 4 * nmat * nmat; ++i)\n jacobian[i] = 0.0;\n for (int m = 0; m < nmat; ++m) {\n jacobian[m] = 1.0;\n jacobian[2 * nmat + nmat + m] = 1.0;\n }\n jacobian[2 * 2 * nmat] = dpdv[0];\n jacobian[nmat * 2 * nmat + nmat - 1] = -dpdv[nmat - 1];\n jacobian[(nmat + 1) * 2 * nmat] = dtdv[0];\n jacobian[(2 * nmat - 1) * 2 * nmat + nmat - 1] = -dtdv[nmat - 1];\n jacobian[2 * 2 * nmat + nmat] = dpde[0];\n jacobian[nmat * 2 * nmat + 2 * nmat - 1] = -dpde[nmat - 1];\n jacobian[(nmat + 1) * 2 * nmat + nmat] = dtde[0];\n jacobian[(2 * nmat - 1) * 2 * nmat + 2 * nmat - 1] = -dtde[nmat - 1];\n for (int m = 1; m < nmat - 1; ++m) {\n jacobian[(1 + m) * 2 * nmat + m] = -dpdv[m];\n jacobian[(2 + m) * 2 * nmat + m] = dpdv[m];\n jacobian[(nmat + m) * 2 * nmat + m] = -dtdv[m];\n jacobian[(nmat + m + 1) * 2 * nmat + m] = dtdv[m];\n jacobian[(1 + m) * 2 * nmat + nmat + m] = -dpde[m];\n jacobian[(2 + m) * 2 * nmat + nmat + m] = dpde[m];\n jacobian[(nmat + m) * 2 * nmat + nmat + m] = -dtde[m];\n jacobian[(nmat + m + 1) * 2 * nmat + nmat + m] = dtde[m];\n }\n for (int i = 0; i < 2 * nmat; ++i)\n dx[i] = residual[i];\n if (!solve_Ax_b<2 * nmat>(jacobian, dx)) {\n // do something to crash out? Tell folks what happened?\n#ifndef KOKKOS_ENABLE_CUDA\n printf(\"crashing out at iteration: %i\\n\", niter);\n#endif // KOKKOS_ENABLE_CUDA\n converged = false;\n // std::cout << \"Crashing out on iteration \"<< niter << std::endl;\n break;\n }\n // Now, get overall scaling limit\n Real scale = 1.0;\n for (int m = 0; m < nmat; ++m) {\n Real vt = vfrac[m] + scale * dx[m];\n if (vt < 0.0) {\n scale = -0.1 * vfrac[m] / dx[m];\n } else if (vt > 1.0) {\n scale = 0.1 * (1.0 - vfrac[m]) / dx[m];\n }\n // maybe the below is dangerous??\n // const Real dt = (dtdv[m] * dx[m] + dtde[m] * dx[m + nmat]);\n // const Real tt = temp[m] + scale * dt;\n // if (tt < 0.0)\n // scale = -0.1 * temp[m] / dt;\n }\n // Now apply the overall scaling\n for (int i = 0; i < 2 * nmat; ++i)\n dx[i] *= scale;\n // Line search\n Real gradfdx = -2.0 * scale * err;\n scale = 1.0;\n Real err_old = err;\n int line_iter = 0;\n do {\n for (int m = 0; m < nmat; ++m) {\n vtemp[m] = vfrac[m] + scale * dx[m];\n rtemp[m] = rhobar[m] / vtemp[m];\n utemp[m] = u[m] + scale * dx[nmat + m];\n sie[m] = utemp[m] / rhobar[m];\n temp[m] =\n eos[ofst(m)].TemperatureFromDensityInternalEnergy(rtemp[m], sie[m], Cache[m]);\n switch (eos_choice[m]) {\n case EosPreference::Rhoe:\n press[m] =\n eos[ofst(m)].PressureFromDensityInternalEnergy(rtemp[m], sie[m], Cache[m]);\n break;\n case EosPreference::RhoT:\n press[m] =\n eos[ofst(m)].PressureFromDensityTemperature(rtemp[m], temp[m], Cache[m]);\n break;\n }\n }\n pte_residual(utot, vtemp, utemp, temp, press, residual);\n Real err = 0;\n for (int i = 0; i < 2 * nmat; ++i)\n err += residual[i] * residual[i];\n err *= 0.5;\n line_iter++;\n if (line_iter > line_search_max_iter ||\n err < err_old + line_search_alpha * scale * gradfdx)\n break;\n scale *= 0.5;\n } while (true);\n\n // Update values\n for (int m = 0; m < nmat; ++m) {\n vfrac[m] = vtemp[m];\n rho[m] = rhobar[m] / vfrac[m];\n u[m] = utemp[m];\n sie[m] = u[m] / rhobar[m];\n }\n // Calculate errors\n Real mean_p = vfrac[0] * press[0];\n Real mean_t = rhobar[0] * temp[0];\n Real error_p = 0.0;\n Real error_t = 0.0;\n for (int m = 1; m < nmat; ++m) {\n mean_p += vfrac[m] * press[m];\n mean_t += rhobar[m] * temp[m];\n error_p += residual[m + 1] * residual[m + 1];\n error_t += residual[m + nmat] * residual[m + nmat];\n }\n mean_t /= rho_total;\n error_p = std::sqrt(error_p);\n error_t = std::sqrt(error_t);\n // Check for convergence\n converged_p = (error_p < pte_rel_tolerance_p * std::abs(mean_p) ||\n error_p < pte_abs_tolerance_p);\n converged_t =\n (error_t < pte_rel_tolerance_t * mean_t || error_t < pte_abs_tolerance_t);\n converged = (converged_p && converged_t);\n if (converged) break;\n // niter++;\n } // while (niter < pte_max_iter && !converged);\n for (int m = 0; m < nmat; ++m)\n vfrac[m] *= vfrac_tot;\n return converged;\n}\n\nstruct NullPtrIndexer {\n PORTABLE_INLINE_FUNCTION Real *operator[](const int i) { return nullptr; }\n};\n\n} // namespace mix_impl\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool pte_closure_flag_with_line(\n EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &niter) {\n using namespace mix_impl;\n return pte_closure_flag_with_line_impl(\n eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes, ComponentEnergies,\n lambdas, [](const int m) { return m; }, niter);\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag_with_line_offset(EOS *eoss, const Real Volume, const Real TotalSIE,\n int const *const ComponentMats,\n const Real *ComponentMasses, Real *ComponentVolumes,\n Real *ComponentEnergies, Real **lambdas, int &niter) {\n using namespace mix_impl;\n if (lambdas == nullptr) {\n NullPtrIndexer lambda_indexer;\n return pte_closure_flag_with_line_impl(\n eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes, ComponentEnergies,\n lambda_indexer, [&ComponentMats](const int m) { return ComponentMats[m]; },\n niter);\n }\n return pte_closure_flag_with_line_impl(\n eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes, ComponentEnergies,\n lambdas, [&ComponentMats](const int m) { return ComponentMats[m]; }, niter);\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool pte_closure_josh(EOSIndexer &&eos, const Real vfrac_tot,\n const Real sie_tot, RealIndexer &&rho,\n RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press,\n LambdaIndexer &&lambda, int &niter) {\n using namespace mix_impl;\n return pte_closure_josh_impl(\n eos, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press, lambda,\n [&](const int m) { return m; }, niter);\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh_offset(EOS *eos, const Real vfrac_tot, const Real sie_tot,\n int const *const Mats, Real *rho, Real *vfrac, Real *sie,\n Real *temp, Real *press, Real **lambda, int &niter) {\n using namespace mix_impl;\n if (lambda == nullptr) {\n NullPtrIndexer lambda_indexer;\n return pte_closure_josh_impl(\n eos, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press, lambda_indexer,\n [&](const int m) { return m; }, niter);\n }\n return pte_closure_josh_impl(\n eos, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press, lambda,\n [&Mats](const int m) { return Mats[m]; }, niter);\n}\n\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_ideal(EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &iter) {\n using namespace mix_params;\n using namespace mix_impl;\n Real TotalMass = 0.0, Vsum = 0.0, Esum = 0.0;\n Real Densities[nmat], Pressures[nmat], Temperatures[nmat], dpdr[nmat], dpde[nmat],\n dtdr[nmat], dtde[nmat], dtpdv[nmat], dtpde[nmat], dtdv[nmat], b[2 * nmat],\n A[4 * nmat * nmat], rtemp[nmat], sietemp[nmat];\n // First, normalize the energies and volumes.\n // This may or may not be close to reality since SIE isn't strictly positive.\n for (int i = 0; i < nmat; ++i)\n TotalMass += ComponentMasses[i];\n bool iszero = false;\n for (int i = 0; i < nmat; ++i)\n iszero &= ComponentVolumes[i] <= 1.0e-16;\n if (iszero)\n for (int i = 0; i < nmat; ++i)\n ComponentVolumes[i] = Volume * ComponentMasses[i] / TotalMass;\n for (int i = 0; i < nmat; ++i)\n Vsum += ComponentVolumes[i];\n for (int i = 0; i < nmat; ++i)\n ComponentVolumes[i] *=\n Volume / Vsum; // Are compilers smart enough to calculate this RHS once?\n for (int i = 0; i < nmat; ++i)\n Esum += ComponentEnergies[i] * ComponentMasses[i];\n if (std::abs(Esum) <\n 0.0001) { // Then we punt and just distribute based on mass fractions\n for (int i = 0; i < nmat; ++i)\n ComponentEnergies[i] = TotalSIE * TotalMass / ComponentMasses[i];\n } else { // Otherwise, we scale\n for (int i = 0; i < nmat; ++i)\n ComponentEnergies[i] *= (TotalSIE * TotalMass / Esum);\n }\n\n // This is the main loop\n constexpr const int pte_max_iter = nmat * pte_max_iter_per_mat;\n for (iter = 0; iter < pte_max_iter; ++iter) {\n // Call the EOSs\n for (int mat = 0; mat < nmat; ++mat) {\n Densities[mat] = ComponentMasses[mat] / ComponentVolumes[mat];\n eoss[mat].PTofRE(Densities[mat], ComponentEnergies[mat], lambdas[mat],\n Pressures[mat], Temperatures[mat], dpdr[mat], dpde[mat], dtdr[mat],\n dtde[mat]);\n // NOTE: here we are re-using this space for d(P/T)/dr and /de using the\n // chain rule If it is deemed useful, we can output this quantity from the\n // EOS call instead\n dtpdv[mat] = -(dtdr[mat] - Temperatures[mat] / Pressures[mat] * dpdr[mat]) /\n Pressures[mat] * square(Densities[mat]);\n dtpde[mat] =\n (dtde[mat] - Temperatures[mat] / Pressures[mat] * dpde[mat]) / Pressures[mat];\n dtdv[mat] = -dtdr[mat] * square(Densities[mat]);\n }\n // Now, zero the matrix and vector\n for (int i = 0; i < 2 * nmat * 2 * nmat; ++i)\n A[i] = 0.0;\n for (int i = 0; i < 2 * nmat; ++i)\n b[i] = 0.0;\n Real vsum = 0.0;\n Real esum = 0.0;\n Real err = 0.0;\n // build matrix and vector\n for (int n = 0; n < nmat - 1; ++n) {\n const int i = n + nmat;\n // First, do the energy side\n A[n * 2 * nmat + n] = dtde[n];\n A[n * 2 * nmat + n + 1] = -dtde[n + 1];\n A[n * 2 * nmat + i] = dtdv[n];\n A[n * 2 * nmat + i + 1] = -dtdv[n + 1];\n A[(nmat - 1) * 2 * nmat + n] = ComponentMasses[n];\n b[n] = Temperatures[n + 1] - Temperatures[n];\n // Now the density half\n A[i * 2 * nmat + n] = dtpde[n];\n A[i * 2 * nmat + n + 1] = -dtpde[n + 1];\n A[i * 2 * nmat + i] = dtpdv[n];\n A[i * 2 * nmat + i + 1] = -dtpdv[n + 1];\n A[(2 * nmat - 1) * 2 * nmat + i] = 1;\n b[i] = Pressures[n + 1] / Temperatures[n + 1] - Pressures[n] / Temperatures[n];\n vsum += ComponentMasses[n] / Densities[n];\n esum += ComponentMasses[n] * ComponentEnergies[n];\n }\n A[(nmat - 1) * 2 * nmat + nmat - 1] = ComponentMasses[nmat - 1];\n b[nmat - 1] = esum - TotalMass * TotalSIE;\n A[4 * nmat * nmat - 1] = 1.0;\n vsum += ComponentMasses[nmat - 1] / Densities[nmat - 1];\n b[2 * nmat - 1] = vsum - Volume;\n for (int i = 0; i < 2 * nmat; ++i)\n err += square(b[i]);\n err *= 0.5;\n // Solve the thing\n if (!solve_Ax_b<2 * nmat>(A, b)) {\n // do something to crash out? Tell folks what happened?\n break;\n }\n\n // LINE SEARCH\n\n // Now, get overall scaling limit\n Real scale = 1.0;\n for (int m = 0; m < nmat; ++m) {\n Real rt = ComponentMasses[m] / (ComponentVolumes[m] + scale * b[m + nmat]);\n if (rt < 0.0) {\n scale = -0.9 * ComponentVolumes[m] / b[m + nmat];\n }\n const Real dt = (dtdv[m] * b[m + nmat] + dtde[m] * b[m]);\n const Real tt = Temperatures[m] + scale * dt;\n if (tt < 0.0) scale = -0.9 * Temperatures[m] / dt;\n }\n // Now apply the overall pre-scaling\n for (int i = 0; i < 2 * nmat; ++i)\n b[i] *= scale;\n // Line search\n Real gradfdx = -2.0 * scale * err;\n scale = 1.0;\n Real err_old = err;\n int line_iter = 0;\n Real err_p, err_t;\n do {\n for (int m = 0; m < nmat; ++m) {\n rtemp[m] = ComponentMasses[m] / (ComponentVolumes[m] + scale * b[m + nmat]);\n sietemp[m] = ComponentEnergies[m] + scale * b[m];\n Temperatures[m] = eoss[m].TemperatureFromDensityInternalEnergy(\n rtemp[m], sietemp[m], lambdas[m]);\n if (eoss[m].PreferredInput() ==\n (thermalqs::density | thermalqs::specific_internal_energy)) {\n Pressures[m] =\n eoss[m].PressureFromDensityInternalEnergy(rtemp[m], sietemp[m], lambdas[m]);\n } else if (eoss[m].PreferredInput() ==\n (thermalqs::density | thermalqs::temperature)) {\n Pressures[m] = eoss[m].PressureFromDensityTemperature(rtemp[m], Temperatures[m],\n lambdas[m]);\n }\n }\n err_p = 0.0;\n err_t = 0.0;\n for (int n = 0; n < nmat - 1; ++n) {\n err_p += square(Pressures[n + 1] - Pressures[n]);\n err_t += square(Temperatures[n + 1] - Temperatures[n]);\n }\n err = 0.5 * (err_p + err_t);\n line_iter++;\n if (line_iter > line_search_max_iter ||\n err < err_old + line_search_alpha * scale * gradfdx)\n break;\n scale *= line_search_fac;\n } while (true);\n\n // END LINE SEARCH\n\n Real mean_p = 0, mean_t = 0;\n\n for (int i = 0; i < 2 * nmat; ++i)\n b[i] *= scale;\n for (int n = 0; n < nmat; ++n) {\n const int i = nmat + n;\n ComponentEnergies[n] += b[n];\n ComponentVolumes[n] += b[i];\n Densities[n] = ComponentMasses[n] / ComponentVolumes[n];\n mean_p += ComponentVolumes[n] * Pressures[n];\n mean_t += ComponentMasses[n] * Temperatures[n];\n }\n mean_p /= Volume;\n mean_t /= TotalMass;\n err_p = std::sqrt(err_p);\n err_t = std::sqrt(err_t);\n bool converged_p =\n (err_p < pte_rel_tolerance_p * std::abs(mean_p) || err_p < pte_abs_tolerance_p);\n bool converged_t =\n (err_t < pte_rel_tolerance_t * std::abs(mean_t) || err_t < pte_abs_tolerance_t);\n if (converged_p && converged_t) {\n return true; // FIXME\n }\n }\n return false; // FIXME\n}\n\n// TODO(JMM): The case statement below to switch between templated\n// versions of these functions is still extremely gross and I hate it.\n// Can we replace with a malloc+free? And if so, what's the\n// consequences of that?\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_flag(int nmat, EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &niter) {\n switch (nmat) {\n case 1:\n return true; // (or should we call the EOS actually?)\n case 2:\n return pte_closure_flag_with_line<2>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n case 3:\n return pte_closure_flag_with_line<3>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n case 4:\n return pte_closure_flag_with_line<4>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n case 5:\n return pte_closure_flag_with_line<5>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n case 6:\n return pte_closure_flag_with_line<6>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n case 7:\n return pte_closure_flag_with_line<7>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n case 8:\n return pte_closure_flag_with_line<8>(eoss, Volume, TotalSIE, ComponentMasses,\n ComponentVolumes, ComponentEnergies, lambdas,\n niter);\n break;\n }\n return false;\n}\nPORTABLE_INLINE_FUNCTION\nbool pte_closure_flag_offset(int nmat, EOS *eoss, const Real Volume, const Real TotalSIE,\n int const *const ComponentMats, const Real *ComponentMasses,\n Real *ComponentVolumes, Real *ComponentEnergies,\n Real **lambdas, int &niter) {\n switch (nmat) {\n case 1:\n return true; // (or should we call the EOS actually?)\n case 2:\n return pte_closure_flag_with_line_offset<2>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 3:\n return pte_closure_flag_with_line_offset<3>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 4:\n return pte_closure_flag_with_line_offset<4>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 5:\n return pte_closure_flag_with_line_offset<5>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 6:\n return pte_closure_flag_with_line_offset<6>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 7:\n return pte_closure_flag_with_line_offset<7>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 8:\n return pte_closure_flag_with_line_offset<8>(eoss, Volume, TotalSIE, ComponentMats,\n ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n }\n return false;\n}\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh(int nmat, EOSIndexer &&eoss, const Real vfrac_tot, const Real sie_tot,\n RealIndexer &&rho, RealIndexer &&vfrac, RealIndexer &&sie,\n RealIndexer &&temp, RealIndexer &&press, LambdaIndexer &&lambdas,\n int &niter) {\n switch (nmat) {\n case 1:\n return true; // (or should we call the EOS actually?)\n case 2:\n return pte_closure_josh<2>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n case 3:\n return pte_closure_josh<3>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n case 4:\n return pte_closure_josh<4>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n case 5:\n return pte_closure_josh<5>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n case 6:\n return pte_closure_josh<6>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n case 7:\n return pte_closure_josh<7>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n case 8:\n return pte_closure_josh<8>(eoss, vfrac_tot, sie_tot, rho, vfrac, sie, temp, press,\n lambdas, niter);\n break;\n }\n return false;\n}\nPORTABLE_INLINE_FUNCTION bool\npte_closure_josh_offset(int nmat, EOS *eoss, const Real vfrac_tot, const Real sie_tot,\n int const *const Mats, Real *rho, Real *vfrac, Real *sie,\n Real *temp, Real *press, Real **lambdas, int &niter) {\n switch (nmat) {\n case 1:\n return true; // (or should we call the EOS actually?)\n case 2:\n return pte_closure_josh_offset<2>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n case 3:\n return pte_closure_josh_offset<3>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n case 4:\n return pte_closure_josh_offset<4>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n case 5:\n return pte_closure_josh_offset<5>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n case 6:\n return pte_closure_josh_offset<6>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n case 7:\n return pte_closure_josh_offset<7>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n case 8:\n return pte_closure_josh_offset<8>(eoss, vfrac_tot, sie_tot, Mats, rho, vfrac, sie,\n temp, press, lambdas, niter);\n break;\n }\n return false;\n}\ntemplate \nPORTABLE_INLINE_FUNCTION bool\npte_closure_ideal(int nmat, EOSIndexer &&eoss, const Real Volume, const Real TotalSIE,\n ConstRealIndexer &&ComponentMasses, RealIndexer &&ComponentVolumes,\n RealIndexer &&ComponentEnergies, LambdaIndexer &&lambdas, int &niter) {\n switch (nmat) {\n case 1:\n return true; // (or should we call the EOS actually?)\n case 2:\n return pte_closure_ideal<2>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 3:\n return pte_closure_ideal<3>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 4:\n return pte_closure_ideal<4>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 5:\n return pte_closure_ideal<5>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 6:\n return pte_closure_ideal<6>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 7:\n return pte_closure_ideal<7>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n case 8:\n return pte_closure_ideal<8>(eoss, Volume, TotalSIE, ComponentMasses, ComponentVolumes,\n ComponentEnergies, lambdas, niter);\n break;\n }\n return false;\n}\n} // namespace singularity\n\n#endif // _SINGULARITY_EOS_CLOSURE_MIXED_CELL_MODELS_\n", "meta": {"hexsha": "919bc4313f5445fce7a0d9bd17456050bac63fdb", "size": 50322, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "singularity-eos/closure/mixed_cell_models.hpp", "max_stars_repo_name": "lanl/singularity-eos", "max_stars_repo_head_hexsha": "c35669b93a492903ad4ce7a15211bd42b7c88d37", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-04-14T15:08:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-28T16:32:19.000Z", "max_issues_repo_path": "singularity-eos/closure/mixed_cell_models.hpp", "max_issues_repo_name": "lanl/singularity-eos", "max_issues_repo_head_hexsha": "c35669b93a492903ad4ce7a15211bd42b7c88d37", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 70.0, "max_issues_repo_issues_event_min_datetime": "2021-04-15T23:08:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T17:43:18.000Z", "max_forks_repo_path": "singularity-eos/closure/mixed_cell_models.hpp", "max_forks_repo_name": "lanl/singularity-eos", "max_forks_repo_head_hexsha": "c35669b93a492903ad4ce7a15211bd42b7c88d37", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-05-21T16:59:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-17T20:52:38.000Z", "avg_line_length": 42.3585858586, "max_line_length": 90, "alphanum_fraction": 0.5969754779, "num_tokens": 14633, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7057850278370112, "lm_q2_score": 0.42250463481418826, "lm_q1q2_score": 0.2981974454435981}} {"text": "#ifndef FSTCLASSIFIERKNN_H\n#define FSTCLASSIFIERKNN_H\n\n/*!======================================================================\n Feature Selection Toolbox 3 source code\n ---------------------------------------\n\t\n \\file classifier_knn.hpp\n \\brief Implements k-Nearest Neighbor classifier\n \\author Petr Somol (somol@utia.cas.cz) with collaborators, see Contacts at http://fst.utia.cz\n \\date March 2011\n \\version 3.1.0.beta\n \\note FST3 was developed using gcc 4.3 and requires\n \\note \\li Boost library (http://www.boost.org/, tested with versions 1.33.1 and 1.44),\n \\note \\li (\\e optionally) LibSVM (http://www.csie.ntu.edu.tw/~cjlin/libsvm/, \n tested with version 3.00)\n \\note Note that LibSVM is required for SVM related tools only,\n as demonstrated in demo12t.cpp, demo23.cpp, demo25t.cpp, demo32t.cpp, etc.\n\n*/ /* \n=========================================================================\nCopyright:\n * FST3 software (with exception of any externally linked libraries) \n is copyrighted by Institute of Information Theory and Automation (UTIA), \n Academy of Sciences of the Czech Republic.\n * FST3 source codes as presented here do not contain code of third parties. \n FST3 may need linkage to external libraries to exploit its functionality\n in full. For details on obtaining and possible usage restrictions \n of external libraries follow their original sources (referenced from\n FST3 documentation wherever applicable).\n * FST3 software is available free of charge for non-commercial use. \n Please address all inquires concerning possible commercial use \n of FST3, or if in doubt, to FST3 maintainer (see http://fst.utia.cz)\n * Derivative works based on FST3 are permitted as long as they remain\n non-commercial only.\n * Re-distribution of FST3 software is not allowed without explicit\n consent of the copyright holder.\nDisclaimer of Warranty:\n * FST3 software is presented \"as is\", without warranty of any kind, \n either expressed or implied, including, but not limited to, the implied \n warranties of merchantability and fitness for a particular purpose. \n The entire risk as to the quality and performance of the program \n is with you. Should the program prove defective, you assume the cost \n of all necessary servicing, repair or correction.\nLimitation of Liability:\n * The copyright holder will in no event be liable to you for damages, \n including any general, special, incidental or consequential damages \n arising out of the use or inability to use the code (including but not \n limited to loss of data or data being rendered inaccurate or losses \n sustained by you or third parties or a failure of the program to operate \n with any other programs).\n========================================================================== */\n\n#include \n#include \n#include \n#include \n#include \"classifier.hpp\"\n#include \"error.hpp\"\n#include \"global.hpp\"\n\n/*============== Template parameter type naming conventions ==============\n--------- Numeric types: -------------------------------------------------\nDATATYPE - data sample values - usually real numbers (but may be integers\n in text processing etc.)\nREALTYPE - must be real numbers - for representing intermediate results of \n calculations like mean, covariance etc.\nIDXTYPE - index values for enumeration of data samples - (nonnegative) integers, \n extent depends on numbers of samples in data\nDIMTYPE - index values for enumeration of features (dimensions), or classes (not \n class sizes) - (nonnegative) integers, usually lower extent than IDXTYPE, \n but be aware of expressions like _classes*_features*_features ! \n in linearized representations of feature matrices for all classes\nBINTYPE - feature selection marker type - represents ca. <10 different feature \n states (selected, deselected, sel./desel. temporarily 1st nested loop, 2nd...)\nRETURNTYPE - criterion value: real value, but may be extended in future to support \n multiple values \n--------- Class types: ---------------------------------------------------\nSUBSET - class of class type Subset \nCLASSIFIER - class implementing interface defined in abstract class Classifier \nEVALUATOR - class implementing interface defined in abstract class Sequential_Step \nDISTANCE - class implementing interface defined in abstract class Distance \nDATAACCESSOR - class implementing interface defined in abstract class Data_Accessor \nINTERVALCONTAINER - class of class type TIntervaller \nCONTAINER - STL container of class type TInterval \n========================================================================== */\n\nnamespace FST {\n\n//! Implements k-Nearest Neighbor classifier\ntemplate\nclass Classifier_kNN : public Classifier { \npublic:\n\ttypedef Classifier parent;\n\ttypedef boost::shared_ptr PDataAccessor;\n\ttypedef boost::shared_ptr PSubset;\n\ttypedef typename DATAACCESSOR::PPattern PPattern;\n\tClassifier_kNN() {set_k(1); _nns_max_size=1; notify(\"Classifier_kNN constructor.\");}\n\tvirtual ~Classifier_kNN() {notify(\"Classifier_kNN destructor.\");}\n\n\tvoid set_k(const DIMTYPE k) {assert(k>0); _k=k; _nns_max_size=_k;} // NOTE: _nns_max_size may be set larger to help avoiding ties\n\tDIMTYPE get_k() const {return _k;}\n\n\tvirtual bool classify(DIMTYPE &cls, const PPattern &pattern); // classifies pattern, returns the respective class index\n\tvirtual bool train(const PDataAccessor da, const PSubset sub); // with kNN there is actually no training. This just stores pointer to training data to be later accessed from test()\n\tvirtual bool test(RETURNTYPE &result, const PDataAccessor da); // estimates accuracy using designated test data\n\t\n\tClassifier_kNN* clone() const;\n\tClassifier_kNN* sharing_clone() const {throw fst_error(\"Classifier_kNN::sharing_clone() not supported, use Classifier_kNN::clone() instead.\");}\n\tClassifier_kNN* stateless_clone() const {throw fst_error(\"Classifier_kNN::stateless_clone() not supported, use Classifier_kNN::clone() instead.\");}\n\t\n\tvirtual std::ostream& print(std::ostream& os) const;\nprivate:\n\tClassifier_kNN(const Classifier_kNN& cknn); // copy-constructor \nprotected:\n\t// NOTE: for given k it is better to keep ((k-1)*NoOfClasses+1) nearest neighbours to prevent ties (provided enough neighbours exist)\n\t// NOTE: equal neighbour distances to different classes are not handled extra\n\t\n\t//! Holds information on distance and data-class membership of neighbors processed in Classifier_kNN\n\tclass Neighbour{\n\tpublic:\n\t\tNeighbour() {}\n\t\tNeighbour(const RETURNTYPE value, const DIMTYPE cls) {_value=value; _cls=cls;}\n\t\tNeighbour(const Neighbour& nei) {_value=nei._value; _cls=nei._cls;}\t//!< copy constructor\n\t\tRETURNTYPE _value; \n\t\tDIMTYPE _cls;\n\t};\n\tDIMTYPE _k;\n\tDIMTYPE _k_enough;\n\tDIMTYPE _nns_max_size;\n\tvoid sort_in(const RETURNTYPE value, const DIMTYPE cls);\n\tDIMTYPE get_most_freq_cls();\n\ttypename std::list::iterator iter;\n\tstd::list _nns; // implemented descending ... the closest neighbour is the last\n\tstd::vector cls_freqs;\n\t\n\tboost::scoped_ptr _distance;\n\tPDataAccessor _da_train; // with kNN there is actually no training. This is meant to store pointer to training data to be later accessed from test()\n};\n\ntemplate\nClassifier_kNN::Classifier_kNN(const Classifier_kNN& cknn) :\n\t_k(cknn._k),\n\t_k_enough(cknn._k_enough),\n\t_nns_max_size(cknn._nns_max_size),\n\t_nns(cknn._nns),\n\tcls_freqs(cknn.cls_freqs)\n{\n\tnotify(\"Classifier_kNN constructor.\");\n\tif(cknn._distance) _distance.reset(cknn._distance->clone());\n}\n\ntemplate\nClassifier_kNN* Classifier_kNN::clone() const\n{\n\tClassifier_kNN *clone=new Classifier_kNN(*this);\n\tclone->set_cloned();\n\treturn clone;\n}\n\n\ntemplate\nbool Classifier_kNN::train(const PDataAccessor da, const PSubset sub)\n{\n\tassert(da);\n\tassert(sub);\n\tif(!_distance || _distance->get_n()get_n_raw()) _distance.reset(new DISTANCE(sub->get_n_raw()));\n\t_distance->narrow_to(sub);\n\t_da_train=da;\n\treturn true;\n}\n\ntemplate\nbool Classifier_kNN::classify(DIMTYPE &cls, const PPattern &pattern)\n{\n\t// NOTE: uses da_train_loop=0 \n\t// NOTE: da and _da_train may point to the same instance -> be careful with setClass() etc.\n\tassert(_da_train);\n\tassert(_distance);\n\tassert(_distance->get_n()==_da_train->getNoOfFeatures());\n\tassert(_distance->get_d()>0);\n\ttypename DATAACCESSOR::PPattern p2;\n\tIDXTYPE s2,i2;\n\tbool b;\n\tDIMTYPE _feats=_da_train->getNoOfFeatures();\n\tRETURNTYPE val;\n\t\n\tconst DIMTYPE da_train_loop=0; // to avoid mixup of get*Block() loops of different types be careful when calling classify() from a different loop\n\t\n\tcls_freqs.resize(_da_train->getNoOfClasses());\n\t_nns_max_size=(_k-1)*_da_train->getNoOfClasses()+1; // to help avoiding ties\n\t_k_enough=DIMTYPE(floor(0.5*(RETURNTYPE)_k)+1); \n\t\n\t_nns.clear();\n\tfor(DIMTYPE c_train=0;c_train<_da_train->getNoOfClasses();c_train++)\n\t{\n\t\t_da_train->setClass(c_train);\n\t\tfor(b=_da_train->getFirstBlock(TRAIN,p2,s2,da_train_loop);b==true;b=_da_train->getNextBlock(TRAIN,p2,s2,da_train_loop)) for(i2=0;i2distance(pattern,&p2[i2*_feats]);\n\t\t\tsort_in(val,c_train);\n\t\t}\n\t}\n\tcls=get_most_freq_cls();\n\n\treturn true;\n}\n\ntemplate\nbool Classifier_kNN::test(RETURNTYPE &result, const PDataAccessor da)\n{\n\t// NOTE: da and _da_train may point to the same instance -> be careful with setClass() etc.\n\tassert(da);\n\tassert(_da_train);\n\tassert(_distance);\n\tassert(da->getNoOfFeatures()==_da_train->getNoOfFeatures());\n\tassert(_distance->get_n()==_da_train->getNoOfFeatures());\n\ttypename DATAACCESSOR::PPattern p1;\n\tIDXTYPE s1,i1;\n\tbool b;\n\tIDXTYPE count=0, correct=0;\n\tDIMTYPE _feats=da->getNoOfFeatures();\n\tDIMTYPE clstmp;\n\t\n\tconst DIMTYPE da_test_loop=1; // to avoid mixup of get*Block() loops of different types (must not! be 0, see classify())\n\t\n\tcls_freqs.resize(_da_train->getNoOfClasses());\n\t_nns_max_size=(_k-1)*_da_train->getNoOfClasses()+1; // to help avoiding ties\n\t_k_enough=DIMTYPE(floor(0.5*(RETURNTYPE)_k)+1); \n\t\n\tfor(DIMTYPE c_test=0;c_testgetNoOfClasses();c_test++)\n\t{\n\t\tda->setClass(c_test);\n\t\tfor(b=da->getFirstBlock(TEST,p1,s1,da_test_loop);b==true;b=da->getNextBlock(TEST,p1,s1,da_test_loop)) {\n\t\t\tfor(i1=0;i1setClass(c_test); // necessary for the case of da pointing to the same object as _da_train\n\t\t}\n\t}\n\tif(count==0) return false;\n\tresult = (RETURNTYPE)correct/(RETURNTYPE)count;\n\treturn true;\n}\n\ntemplate\nvoid Classifier_kNN::sort_in(const RETURNTYPE value, const DIMTYPE cls)\n{\n\titer=_nns.begin();\n\twhile(iter!=_nns.end() && value < (*iter)._value) iter++;\n\tif(_nns.size()<_nns_max_size || iter!=_nns.begin()) {\n\t\tNeighbour tmp(value,cls);\n\t\t_nns.insert(iter,tmp);\n\t\t// NOTE: ? consider: if(as below && first value!= second value) _nns.pop_front() .. to prevent loosing tie info\n\t\tif(_nns.size()>_nns_max_size) _nns.pop_front();\n\t}\n}\n\ntemplate\nDIMTYPE Classifier_kNN::get_most_freq_cls()\n{ // NOTE: destructs contents of _nns !\n\tassert(_da_train);\n\tDIMTYPE i,c,c_max,max=0;\n\tfor(i=0;i<_da_train->getNoOfClasses();i++) cls_freqs[i]=0;\n\twhile(_nns.size()>0) {\n\t\tc=(_nns.back()._cls);\n\t\tif(++cls_freqs[c]==_k_enough) return c;\n\t\tif(cls_freqs[c]>max) {max=cls_freqs[c]; c_max=c;}\n\t\t_nns.pop_back();\n\t}\n\tif(max>0) return c_max;\n\telse return _da_train->getNoOfClasses(); // wrong class\n}\n\ntemplate\nstd::ostream& Classifier_kNN::print(std::ostream& os) const \n{\n\tos << \"Clasifier_kNN(k=\" << _k << \")\";\n\tif(_distance) os << *_distance;\n\treturn os;\n}\n\n} // namespace\n#endif // FSTCLASSIFIERKNN_H ///:~\n", "meta": {"hexsha": "14395a7c478d6f66dbedf7444ffc061a2fbd3fa8", "size": 13749, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "extern/FST3lib/_src_criteria/classifier_knn.hpp", "max_stars_repo_name": "boussaffawalid/FeatureSelection", "max_stars_repo_head_hexsha": "9768a044c0c0dc2c4a2dc0f6e65413d19e92766c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2015-07-07T20:18:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-23T06:46:02.000Z", "max_issues_repo_path": "extern/FST3lib/_src_criteria/classifier_knn.hpp", "max_issues_repo_name": "boussaffawalid/FeatureSelection", "max_issues_repo_head_hexsha": "9768a044c0c0dc2c4a2dc0f6e65413d19e92766c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-02-08T08:35:28.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-10T08:57:35.000Z", "max_forks_repo_path": "extern/FST3lib/_src_criteria/classifier_knn.hpp", "max_forks_repo_name": "boussaffawalid/FeatureSelection", "max_forks_repo_head_hexsha": "9768a044c0c0dc2c4a2dc0f6e65413d19e92766c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2015-04-13T13:11:19.000Z", "max_forks_repo_forks_event_max_datetime": "2017-02-26T08:18:47.000Z", "avg_line_length": 47.5743944637, "max_line_length": 181, "alphanum_fraction": 0.7288530075, "num_tokens": 3624, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5736784074525096, "lm_q2_score": 0.519521321952093, "lm_q1q2_score": 0.29803816461509924}} {"text": "/* Copyright (c) 2010-2018, Delft University of Technology\n * All rigths reserved\n *\n * This file is part of the Tudat. Redistribution and use in source and\n * binary forms, with or without modification, are permitted exclusively\n * under the terms of the Modified BSD license. You should have received\n * a copy of the license with this file. If not, please or visit:\n * http://tudat.tudelft.nl/LICENSE.\n *\n * References\n * Gentry, A., Smyth, D., and Oliver, W. . The Mark IV Supersonic-Hypersonic Arbitrary Body\n * Program, Volume II - Program Formulation, Douglas Aircraft Aircraft Company, 1973.\n *\n */\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"Tudat/Mathematics/BasicMathematics/mathematicalConstants.h\"\n\n#include \"Tudat/Astrodynamics/Aerodynamics/aerodynamics.h\"\n#include \"Tudat/Astrodynamics/Aerodynamics/hypersonicLocalInclinationAnalysis.h\"\n#include \"Tudat/Mathematics/GeometricShapes/compositeSurfaceGeometry.h\"\n#include \"Tudat/Mathematics/GeometricShapes/surfaceGeometry.h\"\n#include \"Tudat/InputOutput/basicInputOutput.h\"\n\nnamespace tudat\n{\nnamespace aerodynamics\n{\n\nusing Eigen::Vector6d;\nusing mathematical_constants::PI;\n\nusing namespace geometric_shapes;\n\n//! Returns default values of mach number for use in HypersonicLocalInclinationAnalysis.\nstd::vector< double > getDefaultHypersonicLocalInclinationMachPoints(\n const std::string& machRegime )\n{\n std::vector< double > machPoints;\n\n // Set default points for full hypersonic analysis.\n if ( machRegime == \"Full\" )\n {\n machPoints.resize( 6 );\n\n machPoints[ 0 ] = 3.0;\n machPoints[ 1 ] = 4.0;\n machPoints[ 2 ] = 5.0;\n machPoints[ 3 ] = 8.0;\n machPoints[ 4 ] = 10.0;\n machPoints[ 5 ] = 20.0;\n }\n\n // Set default points for low hypersonic analysis.\n else if ( machRegime == \"Low\" )\n {\n machPoints.resize( 5 );\n machPoints[ 0 ] = 3.0;\n machPoints[ 1 ] = 4.0;\n machPoints[ 2 ] = 5.0;\n machPoints[ 3 ] = 8.0;\n machPoints[ 4 ] = 10.0;\n }\n\n // Set default points for high hypersonic analysis.\n else if ( machRegime == \"High\" )\n {\n machPoints.resize( 4 );\n machPoints[ 0 ] = 5.0;\n machPoints[ 1 ] = 8.0;\n machPoints[ 2 ] = 10.0;\n machPoints[ 3 ] = 20.0;\n }\n return machPoints;\n}\n\n//! Returns default values of angle of attack for use in HypersonicLocalInclinationAnalysis.\nstd::vector< double > getDefaultHypersonicLocalInclinationAngleOfAttackPoints( )\n{\n std::vector< double > angleOfAttackPoints;\n\n // Set number of data points and allocate memory.\n angleOfAttackPoints.resize( 11 );\n\n // Set default values, 0 to 40 degrees, with steps of 5 degrees.\n for ( int i = 0; i < 11; i++ )\n {\n angleOfAttackPoints[ i ] =\n ( static_cast< double >( i ) * 5.0 * PI / 180.0 );\n }\n return angleOfAttackPoints;\n}\n\n//! Returns default values of angle of sideslip for use in HypersonicLocalInclinationAnalysis.\nstd::vector< double > getDefaultHypersonicLocalInclinationAngleOfSideslipPoints( )\n{\n std::vector< double > angleOfSideslipPoints;\n\n // Set number of data points and allocate memory.\n angleOfSideslipPoints.resize( 2 );\n\n // Set default values, 0 and 1 degrees.\n angleOfSideslipPoints[ 0 ] = 0.0;\n angleOfSideslipPoints[ 1 ] = 1.0 * PI / 180.0;\n\n return angleOfSideslipPoints;\n}\n\n//! Function that saves the vehicle mesh data used for a HypersonicLocalInclinationAnalysis to a file\nvoid saveVehicleMeshToFile(\n const std::shared_ptr< HypersonicLocalInclinationAnalysis > localInclinationAnalysis,\n const std::string directory,\n const std::string filePrefix )\n{\n std::vector< boost::multi_array< Eigen::Vector3d, 2 > > meshPoints =\n localInclinationAnalysis->getMeshPoints( );\n std::vector< boost::multi_array< Eigen::Vector3d, 2 > > meshSurfaceNormals =\n localInclinationAnalysis->getPanelSurfaceNormals( );\n\n\n// boost::array< int, 3 > independentVariables;\n// independentVariables[ 0 ] = 0;\n// independentVariables[ 1 ] = 6;\n// independentVariables[ 2 ] = 0;\n\n// std::vector< std::vector< std::vector< double > > > pressureCoefficients =\n// localInclinationAnalysis->getPressureCoefficientList( independentVariables );\n\n int counter = 0;\n std::map< int, Eigen::Vector3d > meshPointsList;\n std::map< int, Eigen::Vector3d > surfaceNormalsList;\n// std::map< int, Eigen::Vector1d > pressureCoefficientsList;\n\n for( unsigned int i = 0; i < meshPoints.size( ); i++ )\n {\n for( unsigned int j = 0; j < meshPoints.at( i ).shape( )[ 0 ] - 1; j++ )\n {\n for( unsigned int k = 0; k < meshPoints.at( i ).shape( )[ 1 ] - 1; k++ )\n {\n meshPointsList[ counter ] = meshPoints[ i ][ j ][ k ];\n surfaceNormalsList[ counter ] = meshSurfaceNormals[ i ][ j ][ k ];\n// pressureCoefficientsList[ counter ] = ( Eigen::Vector1d( ) << pressureCoefficients[ i ][ j ][ k ] ).finished( );\n counter++;\n }\n }\n }\n\n input_output::writeDataMapToTextFile(\n meshPointsList, filePrefix + \"ShapeFile.dat\", directory );\n input_output::writeDataMapToTextFile(\n surfaceNormalsList, filePrefix + \"SurfaceNormalFile.dat\", directory );\n\n// input_output::writeDataMapToTextFile(\n// pressureCoefficientsList, filePrefix + \"pressureCoefficientFile.dat\", directory );\n}\n\n\n//! Default constructor.\nHypersonicLocalInclinationAnalysis::HypersonicLocalInclinationAnalysis(\n const std::vector< std::vector< double > >& dataPointsOfIndependentVariables,\n const std::shared_ptr< SurfaceGeometry > inputVehicleSurface,\n const std::vector< int >& numberOfLines,\n const std::vector< int >& numberOfPoints,\n const std::vector< bool >& invertOrders,\n const std::vector< std::vector< int > >& selectedMethods,\n const double referenceArea,\n const double referenceLength,\n const Eigen::Vector3d& momentReferencePoint,\n const bool savePressureCoefficients )\n : AerodynamicCoefficientGenerator< 3, 6 >(\n dataPointsOfIndependentVariables, referenceLength, referenceArea, referenceLength,\n momentReferencePoint, { mach_number_dependent, angle_of_attack_dependent, angle_of_sideslip_dependent },true, false ),\n stagnationPressureCoefficient( 2.0 ),\n ratioOfSpecificHeats( 1.4 ),\n selectedMethods_( selectedMethods ),\n savePressureCoefficients_( savePressureCoefficients )\n{\n // Set geometry if it is a single surface.\n if ( std::dynamic_pointer_cast< SingleSurfaceGeometry > ( inputVehicleSurface ) !=\n std::shared_ptr< SingleSurfaceGeometry >( ) )\n {\n // Set number of geometries and allocate memory.\n vehicleParts_.resize( 1 );\n\n vehicleParts_[ 0 ] = std::make_shared< LawgsPartGeometry >( );\n vehicleParts_[ 0 ]->setReversalOperator( invertOrders[ 0 ] );\n\n // If part is not already a LaWGS part, convert it.\n if ( std::dynamic_pointer_cast< LawgsPartGeometry >\n ( inputVehicleSurface ) ==\n std::shared_ptr< LawgsPartGeometry >( ) )\n {\n // Convert geometry to LaWGS surface mesh and set in vehicleParts_ list.\n vehicleParts_[ 0 ]->setMesh(\n std::dynamic_pointer_cast< SingleSurfaceGeometry > ( inputVehicleSurface ),\n numberOfLines[ 0 ], numberOfPoints[ 0 ] );\n }\n\n // Else, set geometry directly.\n else\n {\n vehicleParts_[ 0 ] = std::dynamic_pointer_cast< LawgsPartGeometry >\n ( inputVehicleSurface );\n }\n }\n\n // Set geometry if it is a composite surface.\n else if ( std::dynamic_pointer_cast< CompositeSurfaceGeometry >( inputVehicleSurface ) !=\n std::shared_ptr< CompositeSurfaceGeometry >( ) )\n {\n // Dynamic cast to composite surface geometry for further processing.\n std::shared_ptr< CompositeSurfaceGeometry > compositeSurfaceGeometry_ =\n std::dynamic_pointer_cast< CompositeSurfaceGeometry >( inputVehicleSurface );\n\n // Set number of geometries and allocate memory.\n int numberOfVehicleParts =\n compositeSurfaceGeometry_->getNumberOfSingleSurfaceGeometries( );\n vehicleParts_.resize( numberOfVehicleParts );\n\n // Iterate through all parts and set them in vehicleParts_ list.\n for ( int i = 0; i < numberOfVehicleParts; i++ )\n {\n // If part is not already a LaWGS part, convert it.\n if ( std::dynamic_pointer_cast< LawgsPartGeometry >\n ( compositeSurfaceGeometry_->getSingleSurfaceGeometry( i ) ) ==\n std::shared_ptr< LawgsPartGeometry >( ) )\n {\n vehicleParts_[ i ] = std::make_shared< LawgsPartGeometry >( );\n vehicleParts_[ i ]->setReversalOperator( invertOrders[ i ] );\n\n // Convert geometry to LaWGS and set in list.\n vehicleParts_[ i ]->setMesh(\n compositeSurfaceGeometry_->getSingleSurfaceGeometry( i ),\n numberOfLines[ i ], numberOfPoints[ i ] );\n }\n\n // Else, set geometry directly.\n else\n {\n vehicleParts_[ i ] = std::dynamic_pointer_cast< LawgsPartGeometry >(\n compositeSurfaceGeometry_->getSingleSurfaceGeometry( i ) );\n }\n }\n }\n\n // Allocate memory for panel inclinations and pressureCoefficient_.\n inclination_.resize( vehicleParts_.size( ) );\n pressureCoefficient_.resize( vehicleParts_.size( ) );\n for ( unsigned int i = 0 ; i < vehicleParts_.size( ); i++ )\n {\n inclination_[ i ].resize( vehicleParts_[ i ]->getNumberOfLines( ) );\n pressureCoefficient_[ i ].resize( vehicleParts_[ i ]->getNumberOfLines( ) );\n for ( int j = 0 ; j < vehicleParts_[ i ]->getNumberOfLines( ) ; j++ )\n {\n inclination_[ i ][ j ].resize( vehicleParts_[ i ]->getNumberOfPoints( ) );\n pressureCoefficient_[ i ][ j ].resize( vehicleParts_[ i ]->getNumberOfPoints( ) );\n }\n }\n\n boost::array< int, 3 > numberOfPointsPerIndependentVariables;\n for( int i = 0; i < 3; i++ )\n {\n numberOfPointsPerIndependentVariables[ i ] =\n dataPointsOfIndependentVariables_[ i ].size( );\n }\n\n isCoefficientGenerated_.resize( numberOfPointsPerIndependentVariables );\n\n std::fill( isCoefficientGenerated_.origin( ),\n isCoefficientGenerated_.origin( ) + isCoefficientGenerated_.num_elements( ), 0 );\n\n generateCoefficients( );\n createInterpolator( );\n}\n\n//! Get aerodynamic coefficients.\nVector6d HypersonicLocalInclinationAnalysis::getAerodynamicCoefficientsDataPoint(\n const boost::array< int, 3 > independentVariables )\n{\n if( isCoefficientGenerated_( independentVariables ) == 0 )\n {\n determineVehicleCoefficients( independentVariables );\n }\n\n // Return requested coefficients.\n return aerodynamicCoefficients_( independentVariables );\n}\n\n//! Generate aerodynamic database.\nvoid HypersonicLocalInclinationAnalysis::generateCoefficients( )\n{\n // Allocate variable to pass to coefficient determination for independent\n // variable indices.\n boost::array< int, 3 > independentVariableIndices;\n\n // Iterate over all combinations of independent variables.\n for ( unsigned int i = 0 ; i < dataPointsOfIndependentVariables_[ 0 ].size( ) ; i++ )\n {\n independentVariableIndices[ 0 ] = i;\n for ( unsigned int j = 0 ; j < dataPointsOfIndependentVariables_[\n 1 ].size( ) ; j++ )\n {\n independentVariableIndices[ 1 ] = j;\n for ( unsigned int k = 0 ; k < dataPointsOfIndependentVariables_[\n 2 ].size( ) ; k++ )\n {\n independentVariableIndices[ 2 ] = k;\n\n determineVehicleCoefficients( independentVariableIndices );\n }\n }\n }\n}\n\n//! Generate aerodynamic coefficients at a single set of independent variables.\nvoid HypersonicLocalInclinationAnalysis::determineVehicleCoefficients(\n const boost::array< int, 3 > independentVariableIndices )\n{\n // Declare coefficients vector and initialize to zeros.\n Vector6d coefficients = Vector6d::Zero( );\n\n // Loop over all vehicle parts, calculate aerodynamic coefficients and add\n // to aerodynamicCoefficients_.\n for ( unsigned int i = 0 ; i < vehicleParts_.size( ) ; i++ )\n {\n coefficients += determinePartCoefficients( i, independentVariableIndices );\n }\n\n if( savePressureCoefficients_ )\n {\n pressureCoefficientList_[ independentVariableIndices ] = pressureCoefficient_;\n }\n\n aerodynamicCoefficients_( independentVariableIndices ) = coefficients;\n isCoefficientGenerated_( independentVariableIndices ) = 1;\n}\n\n//! Determine aerodynamic coefficients of a single vehicle part.\nVector6d HypersonicLocalInclinationAnalysis::determinePartCoefficients(\n const int partNumber, const boost::array< int, 3 > independentVariableIndices )\n{\n // Declare and determine angles of attack and sideslip for analysis.\n double angleOfAttack = dataPointsOfIndependentVariables_[ 1 ]\n [ independentVariableIndices[ 1 ] ];\n\n double angleOfSideslip = dataPointsOfIndependentVariables_[ 2 ]\n [ independentVariableIndices[ 2 ] ];\n\n // Declare partCoefficient vector.\n Vector6d partCoefficients = Vector6d::Zero( );\n\n // Check whether the inclinations of the vehicle part have already been computed.\n if ( previouslyComputedInclinations_.count( std::pair< double, double >(\n angleOfAttack, angleOfSideslip ) ) == 0 )\n {\n // Determine panel inclinations for part.\n determineInclinations( angleOfAttack, angleOfSideslip );\n\n // Add panel inclinations to container\n previouslyComputedInclinations_[ std::pair< double, double >(\n angleOfAttack, angleOfSideslip ) ] = inclination_;\n }\n\n else\n {\n // Fetch inclinations from container\n inclination_ = previouslyComputedInclinations_[ std::pair< double, double >(\n angleOfAttack, angleOfSideslip ) ];\n }\n\n // Set pressureCoefficient_ array for given independent variables.\n determinePressureCoefficients( partNumber, independentVariableIndices );\n\n // Calculate force coefficients from pressure coefficients.\n partCoefficients.segment( 0, 3 ) = calculateForceCoefficients( partNumber );\n\n // Calculate moment coefficients from pressure coefficients.\n partCoefficients.segment( 3, 3 ) = calculateMomentCoefficients( partNumber );\n\n return partCoefficients;\n}\n\n//! Determine the pressure coefficients on a single vehicle part.\nvoid HypersonicLocalInclinationAnalysis::determinePressureCoefficients(\n const int partNumber, const boost::array< int, 3 > independentVariableIndices )\n{\n // Retrieve Mach number.\n double machNumber = dataPointsOfIndependentVariables_[ 0 ]\n [ independentVariableIndices[ 0 ] ];\n\n // Determine stagnation point pressure coefficients. Value is computed once\n // here to prevent its calculation in inner loop.\n stagnationPressureCoefficient = computeStagnationPressure(\n machNumber, ratioOfSpecificHeats );\n\n updateCompressionPressures( machNumber, partNumber );\n updateExpansionPressures( machNumber, partNumber );\n}\n\n//! Determine force coefficients from pressure coefficients.\nEigen::Vector3d HypersonicLocalInclinationAnalysis::calculateForceCoefficients(\n const int partNumber )\n{\n // Declare force coefficient vector and intialize to zeros.\n Eigen::Vector3d forceCoefficients = Eigen::Vector3d::Zero( );\n\n // Loop over all panels and add pressures, scaled by panel area, to force\n // coefficients.\n for ( int i = 0 ; i < vehicleParts_[ partNumber ]->getNumberOfLines( ) - 1 ; i++ )\n {\n for ( int j = 0 ; j < vehicleParts_[ partNumber ]->getNumberOfPoints( ) - 1 ; j++)\n {\n forceCoefficients -=\n pressureCoefficient_[ partNumber ][ i ][ j ] *\n vehicleParts_[ partNumber ]->getPanelArea( i, j ) *\n vehicleParts_[ partNumber ]->getPanelSurfaceNormal( i, j );\n }\n }\n\n // Normalize result by reference area.\n forceCoefficients /= referenceArea_;\n\n return forceCoefficients;\n}\n\n//! Determine moment coefficients from pressure coefficients.\nEigen::Vector3d HypersonicLocalInclinationAnalysis::calculateMomentCoefficients(\n const int partNumber )\n{\n // Declare moment coefficient vector and intialize to zeros.\n Eigen::Vector3d momentCoefficients = Eigen::Vector3d::Zero( );\n\n // Declare moment arm for panel moment determination.\n Eigen::Vector3d referenceDistance;\n\n // Loop over all panels and add moments due pressures.\n for ( int i = 0 ; i < vehicleParts_[ partNumber ]->getNumberOfLines( ) - 1 ; i++ )\n {\n for ( int j = 0 ; j < vehicleParts_[ partNumber ]->getNumberOfPoints( ) - 1 ; j++ )\n {\n // Determine moment arm for given panel centroid.\n referenceDistance = ( vehicleParts_[ partNumber ]->getPanelCentroid( i, j ) -\n momentReferencePoint_ );\n\n momentCoefficients -=\n pressureCoefficient_[ partNumber ][ i ][ j ] *\n vehicleParts_[ partNumber ]->getPanelArea( i, j ) *\n ( referenceDistance.cross( vehicleParts_[ partNumber ]->\n getPanelSurfaceNormal( i, j ) ) );\n }\n }\n\n // Scale result by reference length and area.\n momentCoefficients /= ( referenceLength_ * referenceArea_ );\n\n return momentCoefficients;\n}\n\n//! Determines the inclination angle of panels on a single part.\nvoid HypersonicLocalInclinationAnalysis::determineInclinations( const double angleOfAttack,\n const double angleOfSideslip )\n{\n // Declare free-stream velocity vector.\n Eigen::Vector3d freestreamVelocityDirection;\n\n // Set freestream velocity vector in body frame.\n double freestreamVelocityDirectionX = cos( angleOfAttack )* cos( angleOfSideslip );\n double freestreamVelocityDirectionY = sin( angleOfSideslip );\n double freestreamVelocityDirectionZ = sin( angleOfAttack ) * cos( angleOfSideslip );\n freestreamVelocityDirection( 0 ) = freestreamVelocityDirectionX;\n freestreamVelocityDirection( 1 ) = freestreamVelocityDirectionY;\n freestreamVelocityDirection( 2 ) = freestreamVelocityDirectionZ;\n\n // Declare cosine of inclination angle.\n double cosineOfInclination;\n\n // Loop over all panels of given vehicle part and set inclination angles.\n for( unsigned int k = 0; k < vehicleParts_.size( ); k++ )\n {\n for ( int i = 0 ; i < vehicleParts_[ k ]->getNumberOfLines( ) - 1 ; i++ )\n {\n for ( int j = 0 ; j < vehicleParts_[ k ]->getNumberOfPoints( ) - 1 ; j++ )\n {\n\n // Determine cosine of inclination angle from inner product between\n // surface normal and free-stream direction.\n cosineOfInclination = vehicleParts_[ k ]->\n getPanelSurfaceNormal( i, j ).\n dot( freestreamVelocityDirection );\n\n // Set inclination angle.\n inclination_[ k ][ i ][ j ] = PI / 2.0 - acos( cosineOfInclination );\n }\n }\n }\n}\n\n//! Determine compression pressure coefficients on all parts.\nvoid HypersonicLocalInclinationAnalysis::updateCompressionPressures( const double machNumber,\n const int partNumber )\n{\n int method = selectedMethods_[ 0 ][ partNumber ];\n\n std::function< double( double ) > pressureFunction;\n\n // Switch to analyze part using correct method.\n switch( method )\n {\n case 0:\n pressureFunction =\n std::bind( aerodynamics::computeNewtonianPressureCoefficient, std::placeholders::_1 );\n break;\n\n case 1:\n pressureFunction =\n std::bind( aerodynamics::computeModifiedNewtonianPressureCoefficient, std::placeholders::_1,\n stagnationPressureCoefficient );\n break;\n\n case 2:\n // Method currently disabled.\n break;\n\n case 3:\n // Method currently disabled.\n break;\n\n case 4:\n pressureFunction =\n std::bind( aerodynamics::computeEmpiricalTangentWedgePressureCoefficient, std::placeholders::_1,\n machNumber );\n break;\n\n case 5:\n pressureFunction =\n std::bind( aerodynamics::computeEmpiricalTangentConePressureCoefficient, std::placeholders::_1,\n machNumber );\n break;\n\n case 6:\n pressureFunction =\n std::bind( aerodynamics::computeModifiedDahlemBuckPressureCoefficient, std::placeholders::_1,\n machNumber );\n break;\n\n case 7:\n pressureFunction =\n std::bind( aerodynamics::computeVanDykeUnifiedPressureCoefficient, std::placeholders::_1,\n machNumber, ratioOfSpecificHeats, 1 );\n break;\n\n case 8:\n pressureFunction =\n std::bind( aerodynamics::computeSmythDeltaWingPressureCoefficient, std::placeholders::_1,\n machNumber );\n break;\n\n case 9:\n pressureFunction =\n std::bind( aerodynamics::computeHankeyFlatSurfacePressureCoefficient, std::placeholders::_1,\n machNumber );\n break;\n\n default:\n break;\n }\n\n for ( int i = 0 ; i < vehicleParts_[ partNumber ]->getNumberOfLines( ) - 1; i++ )\n {\n for ( int j = 0 ; j < vehicleParts_[ partNumber ]->getNumberOfPoints( ) - 1 ; j++ )\n {\n if ( inclination_[ partNumber ][ i ][ j ] > 0 )\n {\n // If panel inclination is positive, calculate pressure coefficient.\n pressureCoefficient_[ partNumber ][ i ][ j ] =\n pressureFunction( inclination_[ partNumber ][ i ][ j ] );\n }\n }\n }\n}\n\n//! Determines expansion pressure coefficients on all parts.\nvoid HypersonicLocalInclinationAnalysis::updateExpansionPressures( const double machNumber,\n const int partNumber )\n{\n // Get analysis method of part to analyze.\n int method = selectedMethods_[ 1 ][ partNumber ];\n\n if ( method == 0 || method == 1 || method == 4 )\n {\n std::function< double( ) > pressureFunction;\n switch( method )\n {\n case 0:\n pressureFunction = std::bind( &aerodynamics::computeVacuumPressureCoefficient,\n machNumber, ratioOfSpecificHeats );\n break;\n\n case 1:\n pressureFunction = [ ]( ){ return 0.0; };\n break;\n\n case 4:\n pressureFunction = std::bind( &aerodynamics::computeHighMachBasePressure,\n machNumber );\n break;\n\n }\n\n // Iterate over all panels on part.\n for ( int i = 0 ; i < vehicleParts_[ partNumber ]->getNumberOfLines( ) - 1 ; i++ )\n {\n for ( int j = 0 ; j < vehicleParts_[ partNumber ]->getNumberOfPoints( ) - 1 ; j++ )\n {\n if ( inclination_[ partNumber ][ i ][ j ] <= 0 )\n {\n // If panel inclination is negative, calculate pressure using\n // Van Dyke unified method.\n pressureCoefficient_[ partNumber ][ i ][ j ] =\n pressureFunction( );\n }\n }\n }\n }\n\n else if( method == 3 || method == 5 || method == 6 )\n {\n\n std::function< double( double ) > pressureFunction;\n\n // Declare local variable.\n double freestreamPrandtlMeyerFunction;\n\n // Switch to analyze part using correct method.\n switch( method )\n {\n case 3:\n // Calculate freestream Prandtl-Meyer function.\n freestreamPrandtlMeyerFunction = aerodynamics::computePrandtlMeyerFunction(\n machNumber, ratioOfSpecificHeats );\n pressureFunction =\n std::bind( &aerodynamics::computePrandtlMeyerFreestreamPressureCoefficient,\n std::placeholders::_1, machNumber, ratioOfSpecificHeats,\n freestreamPrandtlMeyerFunction );\n break;\n\n case 5:\n pressureFunction =\n std::bind( &aerodynamics::computePrandtlMeyerFreestreamPressureCoefficient,\n std::placeholders::_1, machNumber, ratioOfSpecificHeats, -1 );\n break;\n\n case 6:\n pressureFunction = std::bind( &aerodynamics::computeAcmEmpiricalPressureCoefficient,\n std::placeholders::_1, machNumber );\n break;\n }\n\n // Iterate over all panels on part.\n for ( int i = 0 ; i < vehicleParts_[ partNumber ]->getNumberOfLines( ) - 1 ; i++ )\n {\n for ( int j = 0 ; j < vehicleParts_[ partNumber ]->getNumberOfPoints( ) - 1 ; j++ )\n {\n if ( inclination_[ partNumber ][ i ][ j ] <= 0 )\n {\n // If panel inclination is negative, calculate pressure using\n // Van Dyke unified method.\n pressureCoefficient_[ partNumber ][ i ][ j ] =\n pressureFunction( inclination_[ partNumber ][ i ][ j ] );\n }\n }\n }\n }\n\n else\n {\n std::string errorMessage = \"Error, expansion local inclination method number \"\n + std::to_string( method ) + \" not recognized\";\n throw std::runtime_error( errorMessage );\n }\n}\n\n} // namespace aerodynamics\n} // namespace tudat\n", "meta": {"hexsha": "d12ee7a8e7ad4c2d60296cb1e5ac820f3697e543", "size": 26598, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "Tudat/Astrodynamics/Aerodynamics/hypersonicLocalInclinationAnalysis.cpp", "max_stars_repo_name": "J-Westin/tudat", "max_stars_repo_head_hexsha": "82ebe9e6e2dd51d0688b77960e62e980e6b8bcb8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tudat/Astrodynamics/Aerodynamics/hypersonicLocalInclinationAnalysis.cpp", "max_issues_repo_name": "J-Westin/tudat", "max_issues_repo_head_hexsha": "82ebe9e6e2dd51d0688b77960e62e980e6b8bcb8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tudat/Astrodynamics/Aerodynamics/hypersonicLocalInclinationAnalysis.cpp", "max_forks_repo_name": "J-Westin/tudat", "max_forks_repo_head_hexsha": "82ebe9e6e2dd51d0688b77960e62e980e6b8bcb8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2705035971, "max_line_length": 130, "alphanum_fraction": 0.6214377021, "num_tokens": 5984, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7248702880639791, "lm_q2_score": 0.411110869232168, "lm_q1q2_score": 0.29800205420655446}} {"text": "/*\n For more information, please see: http://software.sci.utah.edu\n\n The MIT License\n\n Copyright (c) 2020 Scientific Computing and Imaging Institute,\n University of Utah.\n\n Permission is hereby granted, free of charge, to any person obtaining a\n copy of this software and associated documentation files (the \"Software\"),\n to deal in the Software without restriction, including without limitation\n the rights to use, copy, modify, merge, publish, distribute, sublicense,\n and/or sell copies of the Software, and to permit persons to whom the\n Software is furnished to do so, subject to the following conditions:\n\n The above copyright notice and this permission notice shall be included\n in all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n DEALINGS IN THE SOFTWARE.\n\n\t Author: \t\t\t\t\t\t\tJaume Coll-Font\n\t Last Modification:\t\tSeptember 6 2017\n*/\n\n\n#include \n#include \n\n// Tikhonov specific headers\n#include \n#include \n#include \n#include \n#include \n\n// Datatypes\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// SCIRun structural\n#include \n#include \n#include \n#include \n#include \n\nusing namespace SCIRun;\nusing namespace SCIRun::Core;\nusing namespace SCIRun::Core::Datatypes;\nusing namespace SCIRun::Core::Logging;\nusing namespace SCIRun::Core::Algorithms;\nusing namespace SCIRun::Core::Algorithms::Inverse;\n\n// shared inputs\nconst AlgorithmInputName TikhonovAlgoAbstractBase::ForwardMatrix(\"ForwardMatrix\");\nconst AlgorithmInputName TikhonovAlgoAbstractBase::MeasuredPotentials(\"MeasuredPotentials\");\nconst AlgorithmInputName TikhonovAlgoAbstractBase::WeightingInSourceSpace(\"WeightingInSourceSpace\");\nconst AlgorithmInputName TikhonovAlgoAbstractBase::WeightingInSensorSpace(\"WeightingInSensorSpace\");\n\n// Inputs specific from the Tikhonov SVD module\nconst AlgorithmInputName TikhonovAlgoAbstractBase::matrixU(\"matrixU\");\nconst AlgorithmInputName TikhonovAlgoAbstractBase::singularValues(\"singularValues\");\nconst AlgorithmInputName TikhonovAlgoAbstractBase::matrixV(\"matrixV\");\n\n// outputs\nconst AlgorithmOutputName TikhonovAlgoAbstractBase::InverseSolution(\"InverseSolution\");\nconst AlgorithmOutputName TikhonovAlgoAbstractBase::RegularizationParameter(\"RegularizationParameter\");\nconst AlgorithmOutputName TikhonovAlgoAbstractBase::LambdaArray(\"LambdaArray\");\nconst AlgorithmOutputName TikhonovAlgoAbstractBase::Lambda_Index(\"Lambda_Index\");\nconst AlgorithmOutputName TikhonovAlgoAbstractBase::RegInverse(\"RegInverse\");\n\nALGORITHM_PARAMETER_DEF( Inverse, TikhonovImplementation);\nALGORITHM_PARAMETER_DEF( Inverse, RegularizationMethod);\nALGORITHM_PARAMETER_DEF( Inverse, regularizationChoice);\nALGORITHM_PARAMETER_DEF( Inverse, LambdaFromDirectEntry);\nALGORITHM_PARAMETER_DEF( Inverse, LambdaMin);\nALGORITHM_PARAMETER_DEF( Inverse, LambdaMax);\nALGORITHM_PARAMETER_DEF( Inverse, LambdaNum);\nALGORITHM_PARAMETER_DEF( Inverse, LambdaResolution);\nALGORITHM_PARAMETER_DEF( Inverse, LambdaSliderValue);\n//ALGORITHM_PARAMETER_DEF( Inverse, LambdaCorner);\n//ALGORITHM_PARAMETER_DEF( Inverse, LCurveText);\nALGORITHM_PARAMETER_DEF( Inverse, regularizationSolutionSubcase);\nALGORITHM_PARAMETER_DEF( Inverse, regularizationResidualSubcase);\n\nTikhonovAlgoAbstractBase::TikhonovAlgoAbstractBase()\n{\n\taddParameter(Parameters::TikhonovImplementation, std::string(\"NoMethodSelected\") );\n\taddOption(Parameters::RegularizationMethod, \"lcurve\", \"single|slider|lcurve\");\n\taddParameter(Parameters::regularizationChoice, 0);\n\taddParameter(Parameters::LambdaFromDirectEntry,1e-6);\n\taddParameter(Parameters::LambdaMin,1e-6);\n\taddParameter(Parameters::LambdaMax,1);\n\taddParameter(Parameters::LambdaNum,200);\n\taddParameter(Parameters::LambdaResolution,1e-6);\n\taddParameter(Parameters::LambdaSliderValue,0);\n\taddParameter(Parameters::regularizationSolutionSubcase,solution_constrained);\n\taddParameter(Parameters::regularizationResidualSubcase,residual_constrained);\n}\n\n////// CHECK IF INPUT MATRICES HAVE THE CORRECT SIZE\nbool TikhonovAlgoAbstractBase::checkInputMatrixSizes( const AlgorithmInput & input) const\n{\n\tauto forwardMatrix_ = input.get(ForwardMatrix);\n\tauto measuredData_ = input.get(MeasuredPotentials);\n\tauto sourceWeighting_ = input.get(WeightingInSourceSpace);\n\tauto sensorWeighting_ = input.get(WeightingInSensorSpace);\n\n const int M = forwardMatrix_->nrows();\n const int N = forwardMatrix_->ncols();\n\n // check that rows of fwd matrix equal number of measurements\n if ( M != measuredData_->nrows() )\n {\n \tTHROW_ALGORITHM_INPUT_ERROR(\"Input matrix dimensions must agree.\");\n \treturn false;\n }\n\n // check source regularization matrix sizes\n if (sourceWeighting_)\n {\n if( get(Parameters::regularizationSolutionSubcase).toInt()==solution_constrained )\n {\n // check that the matrix is of appropriate size (equal number of rows as columns in fwd matrix)\n if ( N != sourceWeighting_->ncols() )\n {\n \t\tTHROW_ALGORITHM_INPUT_ERROR(\"Solution Regularization Matrix must have the same number of rows as columns in the Forward Matrix !\");\n \t\treturn false;\n }\n }\n // otherwise, if the source regularization is provided as the squared version (RR^T)\n else if ( get(Parameters::regularizationSolutionSubcase).toInt()==solution_constrained_squared )\n {\n // check that the matrix is of appropriate size and squared (equal number of rows as columns in fwd matrix)\n if ( ( N != sourceWeighting_->nrows() ) || ( N != sourceWeighting_->ncols() ) )\n {\n THROW_ALGORITHM_INPUT_ERROR(\"The squared solution Regularization Matrix must have the same number of rows and columns and must be equal to the number of columns in the Forward Matrix !\");\n\t return false;\n }\n }\n }\n\n // check measurement regularization matrix sizes\n if (sensorWeighting_)\n {\n if (get(Parameters::regularizationResidualSubcase).toInt() == residual_constrained)\n {\n // check that the matrix is of appropriate size (equal number of rows as rows in fwd matrix)\n if(M != sensorWeighting_->ncols())\n {\n THROW_ALGORITHM_INPUT_ERROR(\"Data Residual Weighting Matrix must have the same number of rows as the Forward Matrix !\");\n return false;\n }\n }\n // otherwise if the source covariance matrix is provided in squared form\n else if ( get(Parameters::regularizationResidualSubcase).toInt() == residual_constrained_squared )\n {\n // check that the matrix is of appropriate size and squared (equal number of rows as rows in fwd matrix)\n if( (M != sensorWeighting_->nrows()) || (M != sensorWeighting_->ncols()) )\n {\n THROW_ALGORITHM_INPUT_ERROR(\"Squared data Residual Weighting Matrix must have the same number of rows and columns as number of rows in the Forward Matrix !\");\n return false;\n }\n }\n }\n return true;\n}\n\nAlgorithmOutput TikhonovAlgoAbstractBase::run(const AlgorithmInput & input) const\n{\n\tauto forwardMatrix = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::ForwardMatrix));\n\tauto measuredData = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::MeasuredPotentials));\n\tauto sourceWeighting = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::WeightingInSourceSpace));\n\tauto sensorWeighting = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::WeightingInSensorSpace));\n\n\tauto RegularizationMethod_gotten = getOption(Parameters::RegularizationMethod);\n\tauto implOption = get(Parameters::TikhonovImplementation).toString();\n\n\t// check input MATRICES\n\tcheckInputMatrixSizes( input );\n\n\t// Determine specific Tikhonov Implementation\n\tstd::shared_ptr algoImpl;\n\tif (implOption == \"standardTikhonov\")\n {\n\t\tint regularizationChoice = get(Parameters::regularizationChoice).toInt();\n\t\tint regularizationSolutionSubcase = get(Parameters::regularizationSolutionSubcase).toInt();\n\t\tint regularizationResidualSubcase = get(Parameters::regularizationResidualSubcase).toInt();\n\n\t\talgoImpl = std::make_shared( *forwardMatrix, *measuredData, *sourceWeighting, *sensorWeighting,\n regularizationChoice, regularizationSolutionSubcase, regularizationResidualSubcase);\n\t}\n\telse if (implOption == \"TikhonovSVD\")\n {\n\t\t// get TikhonovSVD special inputs\n\t\tauto matrixU = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::matrixU));\n\t\tauto singularValues = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::singularValues));\n\t\tauto matrixV = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::matrixV));\n\n\t\t// If there is a missing matrix from the precomputed SVD input\n\t\tif (!matrixU || !singularValues || !matrixV)\n\t\t\talgoImpl = std::make_shared(*forwardMatrix, *measuredData, *sourceWeighting, *sensorWeighting);\n\t\telse\n\t\t\talgoImpl = std::make_shared(*forwardMatrix, *measuredData, *sourceWeighting, *sensorWeighting, *matrixU, *singularValues, *matrixV);\n\t}\n\telse if (implOption == \"TSVD\")\n {\n\t\t// get TikhonovSVD special inputs\n\t\tauto matrixU = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::matrixU));\n\t\tauto singularValues = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::singularValues));\n\t\tauto matrixV = castMatrix::toDense(input.get(TikhonovAlgoAbstractBase::matrixV));\n\n\t\t// If there is a missing matrix from the precomputed SVD input\n\t\tif (!matrixU || !singularValues || !matrixV)\n\t\t\talgoImpl = std::make_shared(*forwardMatrix, *measuredData, *sourceWeighting, *sensorWeighting);\n\t\telse\n\t\t\talgoImpl = std::make_shared(*forwardMatrix, *measuredData, *sourceWeighting, *sensorWeighting, *matrixU, *singularValues, *matrixV);\n\t}\n\telse\n {\n\t\tTHROW_ALGORITHM_PROCESSING_ERROR(\"Not a valid Tikhonov Implementation selection\");\n\t}\n\n double lambda = 0;\n int lambda_index = 0;\n AlgorithmOutput output;\n DenseMatrixHandle lambdamatrix;\n //Get Regularization parameter(s) : Lambda\n if ((RegularizationMethod_gotten == \"single\") || (RegularizationMethod_gotten == \"slider\"))\n {\n if (RegularizationMethod_gotten == \"single\")\n {\n // Use single fixed lambda value, entered in UI\n lambda = get(Parameters::LambdaFromDirectEntry).toDouble();\n }\n else if (RegularizationMethod_gotten == \"slider\")\n {\n // Use single fixed lambda value, select via slider\n lambda = get(Parameters::LambdaSliderValue).toDouble();\n }\n lambdamatrix.reset(new DenseMatrix(1,1,lambda));\n }\n else if (RegularizationMethod_gotten == \"lcurve\")\n {\n lambda = computeLcurve( *algoImpl, input, lambdamatrix, lambda_index);\n }\n\telse\n\t{\n\t\tTHROW_ALGORITHM_PROCESSING_ERROR(\"Lambda selection was never set\");\n\t}\n\n // compute final inverse solution\n\tauto solution = algoImpl->computeInverseSolution(lambda, true);\n\n\t// Set outputs\n\n\toutput[InverseSolution] = boost::make_shared(solution);\n\toutput[RegularizationParameter] = boost::make_shared(1, 1, lambda);\n output[LambdaArray] = lambdamatrix;\n output[Lambda_Index]= boost::make_shared(1, 1, lambda_index);\n\n\treturn output;\n}\n\ndouble TikhonovAlgoAbstractBase::computeLcurve( const SCIRun::Core::Algorithms::Inverse::TikhonovImpl& algoImpl, const AlgorithmInput & input , DenseMatrixHandle& lambdamatrix, int& lambda_index) const\n{\n\t// get inputs\n\tauto forwardMatrix = input.get(TikhonovAlgoAbstractBase::ForwardMatrix);\n\tauto measuredData = input.get(TikhonovAlgoAbstractBase::MeasuredPotentials);\n\tauto sourceWeighting = input.get(TikhonovAlgoAbstractBase::WeightingInSourceSpace);\n\tauto sensorWeighting = input.get(TikhonovAlgoAbstractBase::WeightingInSensorSpace);\n // define the step size of the lambda vector to be computed (distance between min and max divided by number of desired lambdas in log scale)\n const int nLambda = get(Parameters::LambdaNum).toInt();\n\tconst double lambdaMin = get(Parameters::LambdaMin).toDouble();\n\tconst double lambdaMax = get(Parameters::LambdaMax).toDouble();\n\tdouble lambda = 0;\n\n\t// prealocate vector of lambdas and eta and rho\n std::vector rho(nLambda, 0.0);\n std::vector eta(nLambda, 0.0);\n\n lambdamatrix.reset(new DenseMatrix(nLambda,3,0.0));\n\n auto lambdaArray = algoImpl.computeLambdaArray( lambdaMin, lambdaMax, nLambda );\n\n DenseMatrix CAx, Rx;\n DenseMatrix solution;\n\n lambdaArray[0] = lambdaMin;\n\n // for all lambdas\n for (int j = 0; j < nLambda; j++)\n {\n solution = algoImpl.computeInverseSolution( lambdaArray[j], false);\n lambdamatrix->put(j,0,lambdaArray[j]);\n\n // if using source regularization matrix, apply it to compute Rx (for the eta computations)\n if (sourceWeighting)\n {\n if (solution.nrows() == sourceWeighting->ncols()) // check that regularization matrix and solution match sizes\n {\n auto sw = castMatrix::toDense(sourceWeighting);\n Rx = (*sw) * solution;\n }\n else\n {\n BOOST_THROW_EXCEPTION(AlgorithmProcessingException() << ErrorMessage(\" Solution weighting matrix unexpectedly does not fit to compute the weighted solution norm. \"));\n }\n }\n else\n Rx = solution;\n\n auto forward = castMatrix::toDense(forwardMatrix);\n auto Ax = (*forward) * solution;\n auto measured = castMatrix::toDense(measuredData);\n auto residualSolution = Ax - (*measured);\n\n // if using source regularization matrix, apply it to compute Rx (for the eta computations)\n if (sensorWeighting)\n {\n auto sw = castMatrix::toDense(sensorWeighting);\n CAx = (*sw) * residualSolution;\n }\n else\n CAx = residualSolution;\n\n // compute rho and eta. Using Frobenious norm when using matrices\n rho[j] = CAx.norm();\n eta[j] = Rx.norm();\n lambdamatrix->put(j,1,rho[j]);\n lambdamatrix->put(j,2,eta[j]);\n }\n\n // Find corner in L-curve\n lambda = FindCorner( rho, eta, lambdaArray, nLambda,lambda_index);\n\n\tLOG_DEBUG(\"Lambda: {}\", lambda);\n // TODO: update GUI\n\n return lambda;\n}\n\n///// Find Corner, find the maximal curvature which corresponds to the L-curve corner\ndouble TikhonovAlgoAbstractBase::FindCorner( const std::vector& rho, const std::vector& eta, const std::vector& lambdaArray, const int nLambda, int& lambda_index )\n{\n\n\tDenseColumnMatrix lrho(nLambda);\n\tDenseColumnMatrix leta(nLambda);\n\n\tfor (int i = 0; i < nLambda; i++)\n\t{\n\t\tlrho[i] = std::log10(rho[i]);\n\t\tleta[i] = std::log10(eta[i]);\n\t}\n\n\t// create L-curve\n\tDenseMatrix Gamma( 2, lrho.nrows());\n\tGamma.row(0) = lrho;\n\tGamma.row(1) = leta;//DenseColumnMatrix::LinSpaced(lrho.nrows(),0,1);\n\n\t// fit spline and compute curvature\n\tDenseColumnMatrix kappa = TikhonovAlgoAbstractBase::InterpolateCurvatureWithSplines( Gamma );\n\n\t// select maximum curvature\n\tkappa.maxCoeff(&lambda_index);\n\n \treturn lambdaArray[lambda_index];\n}\n\nSCIRun::Core::Datatypes::DenseColumnMatrix TikhonovAlgoAbstractBase::InterpolateCurvatureWithSplines( SCIRun::Core::Datatypes::DenseMatrix& samplePoints)\n{\n\n\t// prealoate\n\tint numSamples = samplePoints.ncols();\n\tDenseColumnMatrix kappa = DenseMatrix::Zero( numSamples, 1 );\n\n\t// typedefs needed for the spline\n\ttypedef Eigen::Spline Spline2d;\n\ttypedef Spline2d::KnotVectorType KnotVectorType;\n\ttypedef Spline2d::ControlPointVectorType ControlPointVectorType;\n\n\t// fit cubic spline to data points\n\tControlPointVectorType points = samplePoints;\n\tconst Spline2d spline = Eigen::SplineFitting::Interpolate(points,3);\n\n\t// determine position of samples along the spline curve\n\tKnotVectorType chord_lengths; // knot parameters\n\tEigen::ChordLengths(points, chord_lengths);\n\n\tfor (int i=0; i < numSamples; i++)\n\t{\n\t\t// compute derivatives up to 2nd order\n\t\tauto dpt = spline.derivatives( chord_lengths(i), 2);\n\n\t\t// compute curvature as:\n\t\t//\t\t\tabs( ( ddrho*ddeta - ddrho*deta ) / sqrt( ( deta^2 + drho^2 )^2) )\n\t\tkappa[i] = std::abs( (dpt(0,2) * dpt(1,2) - dpt(0,2) * dpt(1,1)) / //compute curvature\n\t std::sqrt( std::pow(dpt(1,1)*dpt(1,1)+dpt(0,1)*dpt(0,1) , 3.0)) );\n\n\n\t}\n\n\t// return curvature for all points on the Lcurve\n\treturn kappa;\n}\n", "meta": {"hexsha": "607fd7dabb927354aa721eea4e7e3bb17c97ed1d", "size": 17356, "ext": "cc", "lang": "C++", "max_stars_repo_path": "src/Core/Algorithms/Legacy/Inverse/TikhonovAlgoAbstractBase.cc", "max_stars_repo_name": "Haydelj/SCIRun", "max_stars_repo_head_hexsha": "f7ee04d85349b946224dbff183438663e54b9413", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/Core/Algorithms/Legacy/Inverse/TikhonovAlgoAbstractBase.cc", "max_issues_repo_name": "Haydelj/SCIRun", "max_issues_repo_head_hexsha": "f7ee04d85349b946224dbff183438663e54b9413", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Core/Algorithms/Legacy/Inverse/TikhonovAlgoAbstractBase.cc", "max_forks_repo_name": "Haydelj/SCIRun", "max_forks_repo_head_hexsha": "f7ee04d85349b946224dbff183438663e54b9413", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6211031175, "max_line_length": 201, "alphanum_fraction": 0.757605439, "num_tokens": 4426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.4301473485858429, "lm_q1q2_score": 0.29793811256464686}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define REP(i, n) for(int i = 0, i##_MACRO = (n); i < i##_MACRO; i++)\n#define RANGE(i, a, b) for(int i = (a), i##_MACRO = (b); i < i##_MACRO; i++)\n#define EACH(e, a) for(auto&& e : a)\n#define ALL(a) std::begin(a), std::end(a)\n#define RALL(a) std::rbegin(a), std::rend(a)\n#define FILL(a, n) memset((a), n, sizeof(a))\n#define FILLZ(a) FILL(a, 0)\n#define INT(x) (static_cast(x))\n#define PRECISION(x) std::fixed << std::setprecision(x)\n\nusing namespace std;\n\nusing ll = long long;\nusing VI = std::vector;\nusing VI2D = std::vector>;\nusing VLL = std::vector;\nusing VLL2D = std::vector>;\n\nconstexpr int INF = 2e9;\nconstexpr double EPS = 1e-10;\nconstexpr double PI = acos(-1.0);\n\nconstexpr int dx[] = {-1, 0, 1, 0};\nconstexpr int dy[] = {0, -1, 0, 1};\n\ntemplate \nstruct make_vector_type {\n\tusing type =\n\t\ttypename std::vector::type>;\n};\n\ntemplate \nstruct make_vector_type {\n\tusing type = typename std::vector;\n};\n\ntemplate \nauto make_vector_impl(const std::vector& ls, T init_value) {\n\tif constexpr(N == 0) {\n\t\treturn std::vector(ls[N], init_value);\n\t} else {\n\t\treturn typename make_vector_type::type(\n\t\t\tls[N], make_vector_impl(ls, init_value));\n\t}\n}\n\ntemplate \nauto make_vector(const std::size_t (&ls)[N], T init_value) {\n\tstd::vector dimensions(N);\n\tfor(int i = 0; i < N; i++) {\n\t\tdimensions[N - i - 1] = ls[i];\n\t}\n\treturn make_vector_impl(dimensions, init_value);\n}\n\ntemplate \nstd::vector make_vector(std::size_t size, T init_value) {\n\treturn std::vector(size, init_value);\n}\n\ntemplate \nconstexpr int sign(T x) {\n\treturn x < 0 ? -1 : x > 0 ? 1 : 0;\n}\n\ntemplate <>\nconstexpr int sign(double x) {\n\treturn x < -EPS ? -1 : x > EPS ? 1 : 0;\n}\n\ntemplate \nconstexpr void chmax(T& m, U x) {\n\tm = max(m, x);\n}\n\ntemplate \nconstexpr void chmin(T& m, U x) {\n\tm = min(m, x);\n}\n\ntemplate \nconstexpr T square(T x) {\n\treturn x * x;\n}\n\n// 素因数分解\nstd::unordered_map factor(long long n) {\n\tstd::unordered_map factors;\n\t{\n\t\tint i = 0;\n\t\twhile(n % 2 == 0) {\n\t\t\tn /= 2;\n\t\t\ti++;\n\t\t}\n\t\tif(i != 0) {\n\t\t\tfactors[2] = static_cast(i);\n\t\t}\n\t}\n\tfor(long long i = 3; i * i <= n; i += 2) {\n\t\tint j = 0;\n\t\twhile(n % i == 0) {\n\t\t\tn /= i;\n\t\t\tj++;\n\t\t}\n\t\tif(j != 0) {\n\t\t\tfactors[i] = j;\n\t\t}\n\t}\n\tif(n != 1) {\n\t\tfactors[n] = 1;\n\t}\n\treturn factors;\n}\n\nint main() {\n\tll n;\n\tcin >> n;\n\n\tunordered_map factors;\n\tRANGE(i, 1, n + 1) {\n\t\tauto f = factor(i);\n\t\tEACH(e, f) {\n\t\t\tif(factors[e.first] != 0) {\n\t\t\t\tchmax(factors[e.first], e.second);\n\t\t\t} else {\n\t\t\t\tfactors[e.first] = e.second;\n\t\t\t}\n\t\t}\n\t}\n\n\tll product = 1;\n\tEACH(e, factors) {\n\t\tREP(i, e.second) { product *= e.first; }\n\t}\n\tproduct += 1;\n\n\tcout << product << endl;\n\treturn 0;\n}\n", "meta": {"hexsha": "4f7205c59c0943666bd46f80b2c000cc70cf9b78", "size": 3429, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "AtCoder/ARC110/A.cpp", "max_stars_repo_name": "arlechann/atcoder", "max_stars_repo_head_hexsha": "1af08efa6d3a0e8c75e4eaf13e1eda994820b9e2", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "AtCoder/ARC110/A.cpp", "max_issues_repo_name": "arlechann/atcoder", "max_issues_repo_head_hexsha": "1af08efa6d3a0e8c75e4eaf13e1eda994820b9e2", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "AtCoder/ARC110/A.cpp", "max_forks_repo_name": "arlechann/atcoder", "max_forks_repo_head_hexsha": "1af08efa6d3a0e8c75e4eaf13e1eda994820b9e2", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.9085365854, "max_line_length": 76, "alphanum_fraction": 0.6179644211, "num_tokens": 1120, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6150878555160665, "lm_q2_score": 0.48438008427698437, "lm_q1q2_score": 0.2979363072926219}} {"text": "//==================================================================================================\n/*!\n @file\n\n @copyright 2016 NumScale SAS\n\n Distributed under the Boost Software License, Version 1.0.\n (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)\n*/\n//==================================================================================================\n#ifndef BOOST_SIMD_ARCH_COMMON_SCALAR_FUNCTION_EXPM1_HPP_INCLUDED\n#define BOOST_SIMD_ARCH_COMMON_SCALAR_FUNCTION_EXPM1_HPP_INCLUDED\n#include \n\n#ifndef BOOST_SIMD_NO_INVALIDS\n#include \n#include \n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace boost { namespace simd { namespace ext\n{\n namespace bd = boost::dispatch;\n namespace bs = boost::simd;\n BOOST_DISPATCH_OVERLOAD ( expm1_\n , (typename A0)\n , bd::cpu_\n , bd::scalar_< bd::floating_ >\n )\n {\n BOOST_FORCEINLINE A0 operator() (A0 a0) const BOOST_NOEXCEPT\n {\n using sA0 = bd::scalar_of_t;\n #ifndef BOOST_SIMD_NO_INVALIDS\n if(is_nan(a0)) return Nan();\n #endif\n if((a0 < Logeps())) return Mone();\n if((a0 > Maxlog())) return Inf();\n return detail::expm1_kernel::expm1(a0);\n }\n };\n BOOST_DISPATCH_OVERLOAD ( expm1_\n , (typename A0)\n , bd::cpu_\n , bs::std_tag\n , bd::scalar_< bd::floating_ >\n )\n {\n BOOST_FORCEINLINE A0 operator() (const std_tag &, A0 a0) const BOOST_NOEXCEPT\n {\n return std::expm1(a0);\n }\n };\n} } }\n\n\n#endif\n", "meta": {"hexsha": "4722d52ff4a4a290e86c995ae2e2433bbc9f9752", "size": 2281, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "third_party/boost/simd/arch/common/scalar/function/expm1.hpp", "max_stars_repo_name": "SylvainCorlay/pythran", "max_stars_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-02-25T22:23:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-15T15:13:12.000Z", "max_issues_repo_path": "third_party/boost/simd/arch/common/scalar/function/expm1.hpp", "max_issues_repo_name": "SylvainCorlay/pythran", "max_issues_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_party/boost/simd/arch/common/scalar/function/expm1.hpp", "max_forks_repo_name": "SylvainCorlay/pythran", "max_forks_repo_head_hexsha": "908ec070d837baf77d828d01c3e35e2f4bfa2bfa", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-12-12T12:36:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-10T14:27:07.000Z", "avg_line_length": 33.0579710145, "max_line_length": 100, "alphanum_fraction": 0.5808855765, "num_tokens": 540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.640635868562172, "lm_q2_score": 0.46490157137338844, "lm_q1q2_score": 0.2978326219727093}} {"text": "//---------------------------------//\n// This file is part of MuJoCo //\n// Written by Emo Todorov //\n// Copyright (C) 2017 Roboti LLC //\n//---------------------------------//\n\n\n#include \"mujoco.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\nusing namespace Eigen;\n//-------------------------------- macro variables --------------------------------------\n\n// model selection: PENDULUM CARTPOLE CART2POLE CART3POLE SWIMMER3 SWIMMER6 FISH\n#define FISH\n#define CTRL_LIMITTED false\n#define STATE_LINEAR false\n#define LOCAL true\n#define PI 3.141592653\n\n//-------------------------------- global variables -------------------------------------\n\n// user customized parameters\n#if defined(SWIMMER6)\nconst mjtNum t_step = 0.006;\nconst mjtNum cal_step = 0.006;\nconst mjtNum ptb_coef = 0.005;\nconst int step_max = 1500;\nconst int32_t roll_max = 1400;\nconst char* mname = \"swimmer6.xml\";\nconst int ctrl_num = 5;\nconst int NS = 16;\nmjtNum state_nominal[step_max + 1][NS] = { 0 };\n#elif defined(SWIMMER3)\nconst mjtNum t_step = 0.005;//0.01\nconst mjtNum cal_step = 0.005;\nconst mjtNum ptb_coef = 0.008;\nconst int step_max = 1600;//800\nconst int32_t roll_max = 1200;\nconst char* mname = \"swimmer3.xml\";\nconst int ctrl_num = 2;\nconst int NS = 10;\nmjtNum state_nominal[step_max + 1][NS] = { 0 };\n#elif defined(FISH)\nconst mjtNum t_step = 0.001;\nconst mjtNum cal_step = 0.001;\nconst mjtNum ptb_coef = 0.005;\nconst int step_max = 7000;//16000\nconst int roll_max = 1600;\nconst char* mname = \"fish.xml\";\nconst int ctrl_num = 5;\nconst int NS = 26;\nmjtNum state_nominal[step_max + 1][NS] = { 0.0, 0.0, 0, 0, 0, 0, 1, 0, 0 };\n#elif defined(CART2POLE)\nconst mjtNum t_step = 0.05;\nconst int32_t roll_max = 20000; //2w\nconst char* mname = \"cart2pole.xml\";\nconst int step_max = 120;\nconst int ctrl_num = 1;\nconst int NS = 6;\nmjtNum ptb_coef = 0.04;\nmjtNum state_nominal[step_max + 1][NS] = { 0 };\n#elif defined(CART7POLE)\nconst mjtNum t_step = 0.1;\nconst mjtNum ptb_coef = 1;\nconst int step_max = 100;\nconst int32_t roll_max = 20000;\nconst char* mname = \"cart7pole.xml\";\nconst int ctrl_num = 1;\nconst int NS = 16;\nmjtNum state_nominal[step_max + 1][NS] = { 0 };\n#elif defined(CART3POLE)\nconst mjtNum t_step = 0.05;\nconst mjtNum ptb_coef = 0;\nconst int step_max = 140;\nconst int32_t roll_max = 20000;\nconst char* mname = \"cart3pole.xml\";\nconst int ctrl_num = 1;\nconst int NS = 8;\nmjtNum state_nominal[step_max + 1][NS] = { 0 };\n#elif defined(ACROBOT)\nconst mjtNum t_step = 0.01;\nconst mjtNum ptb_coef = 0.02;\nconst int step_max = 700;\nconst int32_t roll_max = 20000;\nconst char* mname = \"acrobot.xml\";\nconst int ctrl_num = 1;\nconst int NS = 4;\nmjtNum state_nominal[step_max + 1][NS] = { -PI, 0, 0, 0 };\n#elif defined(PENDULUM)\nconst mjtNum t_step = 0.1;\nconst mjtNum cal_step = 0.1;\nmjtNum ptb_coef = 0.005;\nconst int step_max = 30;\nconst int32_t roll_max = 500;\nconst char* mname = \"pendulum.xml\";\nconst int ctrl_num = 1;\nconst int NS = 2;\nmjtNum state_nominal[step_max + 1][NS] = { PI, 0.0 };\n#elif defined(CARTPOLE)\nconst mjtNum t_step = 0.1;\nconst mjtNum cal_step = 0.1;\nmjtNum ptb_coef = 0.003;\nconst int step_max = 30;\nconst int32_t roll_max = 600;\nconst char* mname = \"cartpole.xml\";\nconst int ctrl_num = 1;\nconst int NS = 4;\nmjtNum state_nominal[step_max + 1][NS] = { 0, 0, 0, 0.0 };\n#endif\n\n// model\nmjModel* m = 0;\nmjData* d = 0;\nchar lastfile[1000] = \"\";\nchar error[1000];\nstatic int tri_num = 0;\nstatic int32_t trial = 0;\nstatic int index = 0;\nstatic bool cal_flag = true;\nconst long N = NS + ctrl_num;\nconst int n_check = 1;\nmjtNum sysiderr = 0;\nmjtNum delta_x1[12 + ctrl_num] = { 0 };\nmjtNum delta_x2[12] = { 0 };\nmjtNum mat[step_max][12][12 + ctrl_num] = { 0 };\n//mjtNum sum[step_max][NS][NS + ctrl_num] = { 0 };\n//mjtNum dx[step_max + 1][NS];\n//mjtNum delta_xc[step_max + 1][NS + ctrl_num] = { 0 };\n//mjtNum delta_xcs[step_max][NS] = { 0 };\nmjtNum res[NS + ctrl_num][NS + ctrl_num], res6[NS + ctrl_num][NS + ctrl_num], res7[NS][NS + ctrl_num];\nmjtNum ctrl_nominal[step_max * ctrl_num] = { 0 };\nmjtNum ulim = 0;\nint stepite = (int)(t_step / cal_step);\nchar ctrl_buff[20];\nchar para_buff[20];\nchar glstr[10];\nchar *str3, *str;\nFILE *fp, *fp1, *fop, *fop1, *fop2;\nchar mfilename[30];\nchar kfilename[30];\nchar dfilename[30];\n#if LOCAL == false\nchar mfilepre[17] = \"../../../model/\";\nchar kfilepre[17] = \"../../../doc/\";\nchar dfilepre[17] = \"../../../data/\";\n#else \nchar mfilepre[15] = \"\";\nchar kfilepre[15] = \"\";\nchar dfilepre[15] = \"\";\n#endif\n\n// timer\ndouble gettm(void)\n{\n static chrono::system_clock::time_point _start = chrono::system_clock::now();\n chrono::duration elapsed = chrono::system_clock::now() - _start;\n return elapsed.count();\n}\n\n// deallocate and print message\nint finish(const char* msg = 0, mjModel* m = 0, mjData* d = 0)\n{\n // deallocated everything\n if( d )\n mj_deleteData(d);\n if( m )\n mj_deleteModel(m);\n mj_deactivate();\n\n // print message\n if( msg )\n printf(\"%s\\n\", msg);\n\n return 0;\n}\n\n/* Calculate Determinant of the Matrix */\nmjtNum determinant(mjtNum fh[N][N], mjtNum r)\n{\n\tint z, j, i;\n\tmjtNum m = 1, k, det = 1.0;\n\tint rr = (int)r;\n\tmjtNum a[N][N];\n\n\tfor (i = 0; i < rr; i++)\n\t{\n\t\tfor (j = 0; j < r; j++)\n\t\t{\n\t\t\ta[i][j] = fh[i][j];\n\t\t}\n\t}\n\n\tfor (z = 0; z PI) rx = PI - rx;\n\n\tQuaterniond q = AngleAxisd(rx, Vector3d::UnitX())\n\t\t* AngleAxisd(ry, Vector3d::UnitY())\n\t\t* AngleAxisd(rz, Vector3d::UnitZ());\n\n\tEigen::Vector4d b = q.coeffs(); // x y z w\n\n\t*res = b[3];\n\t*(res + 1) = b[0];\n\t*(res + 2) = b[1];\n\t*(res + 3) = b[2];\n}\n\ndouble gaussrand()\n{\n\tstatic double U, V;\n\tstatic int phase = 0;\n\tdouble Z;\n\n\tif (phase == 0)\n\t{\n\t\tU = rand() / (RAND_MAX + 1.0);\n\t\tV = rand() / (RAND_MAX + 1.0);\n\t\tif (U == 0) U = 0.00001;\n\t\tZ = sqrt(-2.0 * log(U)) * sin(2.0 * PI * V);\n\t}\n\telse\n\t{\n\t\tZ = sqrt(-2.0 * log(U)) * cos(2.0 * PI * V);\n\t}\n\tphase = 1 - phase;\n\treturn Z;\n}\n\nvoid get_nominal(mjModel* m, mjData* d)\n{\n\tstatic int index = 0, i, y;\n\tmjtNum temp[4];\n#if STATE_LINEAR == true\n\tstatic int step_max = 1;\n#endif\n\n\tmju_zero(d->qpos, m->nq);\n\tmju_zero(d->qvel, m->nv);\n\tfor (y = 0; y < NS/2; y++)\n\t{\n\t\td->qpos[y] = state_nominal[index][2 * y];\n\t}\n\tfor (y = 0; y < m->nv; y++)\n\t{\n\t\td->qvel[y] = state_nominal[index][2 * y + 1];\n\t}\n\tfor (y = 0; y < ctrl_num; y++)\n\t{\n\t\td->ctrl[y] = ctrl_nominal[index * ctrl_num + y];\n\t}\n\n\tquat2smpl(temp, &(d->qpos[3]));\n\tfor (int k = 0; k < 3; k++)state_nominal[index][2 * k + 6] = temp[k];\n\n\t//for (int k = 0; k < 3; k++)state_nominal[index][2 * k + 6] = d->qpos[k + 4];\n\n\twhile (index < step_max)\n\t{\n\t\tfor (i = 0; i < stepite; i++) mj_step(m, d);\n\n\t\tindex++;\n\t\tfor (y = 0; y < 3; y++)\n\t\t{\n\t\t\tstate_nominal[index][2 * y] = d->qpos[y];\n\t\t}\n\n\t\tquat2smpl(temp, &(d->qpos[3]));\n\t\tfor (int k = 0; k < 3; k++)state_nominal[index][2 * k + 6] = temp[k];\n\n\t\t//for (int k = 0; k < 3; k++)state_nominal[index][2 * k + 6] = d->qpos[k+4];\n\n\t\tfor (y = 7; y < m->nq; y++)\n\t\t{\n\t\t\tstate_nominal[index][2 * (y-1)] = d->qpos[y];\n\t\t}\n\t\tfor (y = 0; y < m->nv; y++)\n\t\t{\n\t\t\tstate_nominal[index][2 * y + 1] = d->qvel[y];\n\t\t}\n\t\tfor (y = 0; y < ctrl_num; y++)\n\t\t{\n\t\t\td->ctrl[y] = ctrl_nominal[index * ctrl_num + y];\n\t\t}\n\t}\n}\n\nvoid sysidcheck(mjModel* m, mjData* d)\n{\n\tstatic int index = 0;\n\tstatic mjtNum t_init;\n\tconst int step_max = 1500;\n\tint i, j, k;\n\tmjtNum dx[n_check][step_max][12];\n\tmjtNum delta_xc[n_check][step_max][12 + ctrl_num] = { 0 };\n\tmjtNum delta_xcs[n_check][step_max][12] = { 0 };\n\tmjtNum temp[4];\n\n\tfor (i = 0; i < 17; i++)\n\t{\n\t\tfor (j = 0; j < n_check; j++)\n\t\t{\n\t\t\tfor (k = 0; k < step_max; k++) delta_xc[j][k][i] = 0.005 * ulim * gaussrand();\n\t\t}\n\t}\n\tfor (i = 0; i < n_check; i++)\n\t{\n\t\tfor (j = 0; j < step_max; j++) mju_mulMatVec(dx[i][j], *mat[j], delta_xc[i][j], 12, 12 + ctrl_num);\n\t}\n\n\tfor (i = 0; i < n_check; i++)\n\t{\n\t\tindex = 0;\n\t\tt_init = d->time;\n\t\tfor (j = 0; j < 3; j++)\n\t\t{\n\t\t\td->qpos[j] = delta_xc[i][index][2 * j] + state_nominal[index][2 * j];\n\t\t}\n\n\t\t//for (k = 0; k < 3; k++) d->qpos[k+4] = delta_xc[i][index][2 * k + 6] + state_nominal[index][2 * k + 6];\n\t\t//d->qpos[3] = sqrt(1 - d->qpos[4] * d->qpos[4] - d->qpos[5] * d->qpos[5] - d->qpos[6] * d->qpos[6]);\n\n\t\tfor (k = 0; k < 3; k++) temp[k] = delta_xc[i][index][2 * k + 6] + state_nominal[index][2 * k + 6];\n\t\tsmpl2quat(&(d->qpos[3]), temp);\n\n\t\tfor (j = 7; j < m->nq; j++)\n\t\t{\n\t\t\td->qpos[j] = state_nominal[index][2 * (j-1)];\n\t\t}\n\t\t//d->qpos[9] = delta_xc[i][index][12] + state_nominal[index][16];\n\t\tfor (j = 0; j < 6; j++)\n\t\t{\n\t\t\td->qvel[j] = delta_xc[i][index][2 * j + 1] + state_nominal[index][2 * j + 1];\n\t\t}\n\t\tfor (j = 6; j < m->nv; j++)\n\t\t{\n\t\t\td->qvel[j] = state_nominal[index][2 * j + 1];\n\t\t}\n\t\t//d->qvel[8] = delta_xc[i][index][13] + state_nominal[index][17];\n\t\tfor (k = 0; k < ctrl_num; k++)\n\t\t{\n\t\t\td->ctrl[k] = delta_xc[i][index][k + 12] + ctrl_nominal[index * ctrl_num + k];\n\t\t}\n\t\twhile (index < step_max - 1)\n\t\t{\n\t\t\tif (d->time - t_init < t_step - 0.00001)\n\t\t\t{\n\t\t\t\tmj_step(m, d);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tfor (int y = 0; y < 3; y++)\n\t\t\t\t{\n\t\t\t\t\tdelta_xcs[i][index][2 * y] = d->qpos[y] - state_nominal[index + 1][2 * y];\n\t\t\t\t}\n\n\t\t\t\tquat2smpl(temp, &(d->qpos[3]));\n\t\t\t\tfor (int k = 0; k < 3; k++) delta_xcs[i][index][2 * k + 6] = temp[k] - state_nominal[index][2 * k + 6];\n\n\t\t\t\t//for (int k = 0; k < 3; k++) delta_xcs[i][index][2 * k + 6] = d->qpos[k+4] - state_nominal[index][2 * k + 6];\n\n\t\t\t\t//delta_xcs[i][index][12] = d->qpos[9] - state_nominal[index + 1][16];\n\t\t\t\tfor (int y = 0; y < 6; y++)\n\t\t\t\t{\n\t\t\t\t\tdelta_xcs[i][index][2 * y + 1] = d->qvel[y] - state_nominal[index + 1][2 * y + 1];\n\t\t\t\t}\n\t\t\t\t//delta_xcs[i][index][13] = d->qvel[8] - state_nominal[index + 1][17];\n\n\t\t\t\tindex++;\n\t\t\t\tt_init = d->time;\n\n\t\t\t\tfor (int y = 0; y < 3; y++)\n\t\t\t\t{\n\t\t\t\t\td->qpos[y] = delta_xc[i][index][2 * y] + state_nominal[index][2 * y];\n\t\t\t\t}\n\n\t\t\t\t//for (int k = 0; k < 3; k++) d->qpos[k+4] = delta_xc[i][index][2 * k + 6] + state_nominal[index][2 * k + 6];\n\t\t\t\t//d->qpos[3] = sqrt(1 - d->qpos[4] * d->qpos[4] - d->qpos[5] * d->qpos[5] - d->qpos[6] * d->qpos[6]);\n\n\t\t\t\tfor (int k = 0; k < 3; k++) temp[k] = delta_xc[i][index][2 * k + 6] + state_nominal[index][2 * k + 6];\n\t\t\t\tsmpl2quat(&(d->qpos[3]), temp);\n\n\t\t\t\tfor (j = 7; j < m->nq; j++)\n\t\t\t\t{\n\t\t\t\t\td->qpos[j] = state_nominal[index][2 * (j - 1)];\n\t\t\t\t}\n\t\t\t\t//d->qpos[9] = delta_xc[i][index][12] + state_nominal[index][16];\n\t\t\t\tfor (int y = 0; y < 6; y++)\n\t\t\t\t{\n\t\t\t\t\td->qvel[y] = delta_xc[i][index][2 * y + 1] + state_nominal[index][2 * y + 1];\n\t\t\t\t}\n\t\t\t\tfor (int y = 6; y < m->nv; y++)\n\t\t\t\t{\n\t\t\t\t\td->qvel[y] = state_nominal[index][2 * y + 1];\n\t\t\t\t}\n\t\t\t\t//d->qvel[8] = delta_xc[i][index][13] + state_nominal[index][17];\n\t\t\t\tfor (int ci = 0; ci < ctrl_num; ci++)\n\t\t\t\t{\n\t\t\t\t\td->ctrl[ci] = delta_xc[i][index][ci + 12] + ctrl_nominal[index * ctrl_num + ci];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfor (int t = 0; t < 12; t++)\n\t\t{\n\t\t\tfor (int h = 0; h < step_max; h++)\n\t\t\t{\n\t\t\t\tif (delta_xcs[i][h][t] != 0) sysiderr += fabs((dx[i][h][t] - delta_xcs[i][h][t]) / delta_xcs[i][h][t]);\n\t\t\t}\n\t\t}\n\t}\n\tsysiderr = sysiderr / (1.0*n_check*step_max*12);\n}\n\nvoid check(mjModel* m, mjData* d)\n{\n//\tstatic int index = 0, h, u, y;\n//#if STATE_LINEAR == true\n//\tstatic int step_max = 1;\n//#endif\n//\n//\tfor (u = 0; u < NS + ctrl_num; u++)\n//\t{\n//\t\tfor (h = 0; h < step_max; h++) delta_xc[h][u] = ptb_coef * ulim * gaussrand();\n//\t}\n//\tfor (h = 0; h < step_max; h++)\n//\t{\n//\t\tmju_mulMatVec(dx[h + 1], *mat[h], delta_xc[h], NS, NS + ctrl_num);\n//\t}\n//\twhile (index < step_max)\n//\t{\n//\t\tfor (y = 0; y < m->nq; y++)\n//\t\t{\n//\t\t\td->qpos[y] = delta_xc[index][2 * y] + state_nominal[index][2 * y];\n//\t\t}\n//\t\tfor (y = 0; y < m->nv; y++)\n//\t\t{\n//\t\t\td->qvel[y] = delta_xc[index][2 * y + 1] + state_nominal[index][2 * y + 1];\n//\t\t}\n//\t\tfor (h = 0; h < ctrl_num; h++)\n//\t\t{\n//\t\t\td->ctrl[h] = ctrl_nominal[index * ctrl_num + h] + delta_xc[index][h + NS];\n//\t\t}\n//\n//\t\tfor (h = 0; h < stepite; h++) mj_step(m, d);\n//\n//\t\tfor (y = 0; y < m->nq; y++)\n//\t\t{\n//\t\t\tdelta_xcs[index][2 * y] = d->qpos[y] - state_nominal[index + 1][2 * y];\n//\t\t}\n//\t\tfor (y = 0; y < m->nv; y++)\n//\t\t{\n//\t\t\tdelta_xcs[index][2 * y + 1] = d->qvel[y] - state_nominal[index + 1][2 * y + 1];\n//\t\t}\n//\t\tindex++;\n//\t}\n}\n\nvoid setcontrol(mjModel* m, mjData* d)\n{\n\tmjtNum temp[4];\n\tstatic int index = 0, i, y;\n#if STATE_LINEAR == true\n\tstatic int step_max = 1;\n#endif\n\n\twhile (index < step_max)\n\t{\n\t\tfor (y = 0; y < 3; y++)\n\t\t{\n\t\t\tdelta_x1[2 * y] = ptb_coef * ulim * gaussrand();\n\t\t\td->qpos[y] = delta_x1[2 * y] + state_nominal[index][2 * y];\n\t\t}\n\t\tfor (int k = 0; k < 3; k++) {\n\t\t\tdelta_x1[2 * k + 6] = ptb_coef * ulim * gaussrand();\n\n\t\t\t//d->qpos[k+4] = delta_x1[2 * k + 6] + state_nominal[index][2 * k + 6];\n\n\t\t\ttemp[k] = delta_x1[2 * k + 6] + state_nominal[index][2 * k + 6];\n\t\t}\n\t\t//d->qpos[3] = sqrt(1 - d->qpos[4] * d->qpos[4] - d->qpos[5] * d->qpos[5] - d->qpos[6] * d->qpos[6]);\n\t\t\n\t\tsmpl2quat(&(d->qpos[3]), temp);\n\t\tfor (int j = 7; j < m->nq; j++)\n\t\t{\n\t\t\td->qpos[j] = state_nominal[index][2 * (j - 1)];\n\t\t}\n\t\t//delta_x1[12] = ptb_coef * ulim * gaussrand();\n\t\t//d->qpos[9] = delta_x1[12] + state_nominal[index][16];\n\t\tfor (y = 0; y < 6; y++)\n\t\t{\n\t\t\tdelta_x1[2 * y + 1] = ptb_coef * ulim * gaussrand();\n\t\t\td->qvel[y] = delta_x1[2 * y + 1]+state_nominal[index][2 * y + 1];\n\t\t}\n\t\tfor (y = 6; y < m->nv; y++)\n\t\t{\n\t\t\td->qvel[y] = state_nominal[index][2 * y + 1];\n\t\t}\n\t\t//delta_x1[13] = ptb_coef * ulim * gaussrand();\n\t\t//d->qvel[8] = delta_x1[13] + state_nominal[index][17];\n\t\tfor (i = 0; i < ctrl_num; i++)\n\t\t{\n\t\t\tdelta_x1[i + 12] = ptb_coef * ulim * gaussrand();\n\t\t\td->ctrl[i] = ctrl_nominal[index * ctrl_num + i] + delta_x1[i + 12];\n\t\t}\n\n\t\tfor (i = 0; i < stepite; i++) mj_step(m, d);\n\n\t\tfor (int y = 0; y < 3; y++)\n\t\t{\n\t\t\tdelta_x2[2 * y] = d->qpos[y] - state_nominal[index + 1][2 * y];\n\t\t}\n\n\t\tquat2smpl(temp, &(d->qpos[3]));\n\t\tfor (int k = 0; k < 3; k++) delta_x2[2 * k + 6] = temp[k] - state_nominal[index][2 * k + 6];\n\t\t\n\t\t//for (int k = 0; k < 3; k++) delta_x2[2 * k + 6] = d->qpos[k+4] - state_nominal[index][2 * k + 6];\n\n\t\t//delta_x2[12] = d->qpos[9] - state_nominal[index + 1][16];\n\t\tfor (int y = 0; y < 6; y++)\n\t\t{\n\t\t\tdelta_x2[2 * y + 1] = d->qvel[y] - state_nominal[index + 1][2 * y + 1];\n\t\t}\n\t\t//delta_x2[13] = d->qvel[8] - state_nominal[index + 1][17];\n\t\t// iteration method\n\t\tfor (y = 0; y < 12; y++)\n\t\t{\n\t\t\tfor (i = 0; i < 17; i++)\n\t\t\t{\n\t\t\t\tmat[index][y][i] = mat[index][y][i] * (1 - 1 / (trial + 1.0)) + delta_x2[y] * delta_x1[i] / ((trial + 1.0) * ptb_coef * ptb_coef * ulim * ulim);\n\t\t\t}\n\t\t}\n\n\t\tif (index == 0)\n\t\t{\n\t\t\tstr3 = glstr;\n\t\t\tsprintf(str3, \"%3.3f\", mat[index][0][1]);\n\t\t\tfwrite(str3, 5, 1, fop);\n\t\t\tfputs(\" \", fop);\n\t\t}\n\t\tindex++;\n\t}\n\tindex = 0;\n\ttrial++;\n}\n\n// main function\nint main(int argc, const char** argv)\n{\n // activate MuJoCo Pro license (this must be *your* activation key)\n\tstrcpy(kfilename, kfilepre);\n\tstrcat(kfilename, \"mjkeysmall.txt\");\n mj_activate(kfilename);\n\n // get filename, determine file type\n std::string filename(mname);\n bool binary = (filename.find(\".mjb\")!=std::string::npos);\n\tstrcpy(mfilename, mfilepre);\n\tstrcat(mfilename, mname);\n\n // load model\n char error[1000] = \"Could not load binary model\";\n if( binary )\n m = mj_loadModel(mfilename, 0);\n else\n m = mj_loadXML(mfilename, 0, error, 1000);\n if( !m )\n return finish(error);\n\n // make data\n d = mj_makeData(m);\n if( !d )\n return finish(\"Could not allocate mjData\", m);\n\n\tif (STATE_LINEAR == true)\n\t{\n\t\t#if defined(CART2POLE)||defined(CART3POLE)||defined(CART7POLE)\n\t\t\t\tstate_nominal[0][2] = PI;\n\t\t#elif defined(PENDULUM)\n\t\t\t\tstate_nominal[0][0] = 0;\n\t\t#elif defined(CARTPOLE)\n\t\t\t\tstate_nominal[0][2] = -PI;\n\t\t#elif defined(ACROBOT)\n\t\t\t\tstate_nominal[0][0] = 0;\n\t\t\t\tstate_nominal[0][2] = -2 * PI;\n\t\t#endif\n\t}\n\n\tsrand((unsigned)time(NULL));\n\tstrcpy(dfilename, dfilepre);\n\tstrcat(dfilename, \"converge.txt\");\n\tif ((fop = fopen(dfilename, \"wt+\")) == NULL) {\n\t\treturn 0;\n\t}\n\tstrcpy(dfilename, dfilepre);\n\tstrcat(dfilename, \"result.txt\");\n\tif ((fp = fopen(dfilename, \"r\")) != NULL)\n\t{\n\t\tfscanf(fp, \"%s\", ctrl_buff);\n\t\tif (ctrl_buff[0] == 'C') {\n\t\t\tfor (int i = 0; i < step_max * ctrl_num; i++)\n\t\t\t{\n\t\t\t\tfscanf(fp, \"%s\", ctrl_buff);\n\t\t\t\tctrl_nominal[i] = atof(ctrl_buff);\n\t\t\t\tif (fabs(ctrl_nominal[i]) > ulim) ulim = fabs(ctrl_nominal[i]);\n\n\t\t\t\t#if CTRL_LIMITTED == true\n\t\t\t\t\tif (ctrl_nominal[i] > m->actuator_ctrlrange[1]) ctrl_nominal[i] = m->actuator_ctrlrange[1];\n\t\t\t\t\telse if (ctrl_nominal[i] < m->actuator_ctrlrange[0]) ctrl_nominal[i] = m->actuator_ctrlrange[0];\n\t\t\t\t#endif\n\t\t\t\t#if STATE_LINEAR == true\n\t\t\t\t\tctrl_nominal[i] = 0;\n\t\t\t\t#endif\n\t\t\t}\n\t\t\tfclose(fp); \n\t\t}\n\t}\n\n // time simulation\n int steps = 0, contacts = 0, constraints = 0;\n double printfraction = 0.1;\n printf(\"\\nSimulation \");\n double start = gettm();\n\tget_nominal(m, d);\n\twhile (trial < roll_max)\n {\n\t\tsetcontrol(m, d);\n\n // accumulate statistics\n steps = steps + stepite;\n contacts += d->ncon;\n constraints += d->nefc;\n\n // print '.' every 10% of duration\n if( trial >= roll_max*printfraction )\n {\n printf(\".\");\n printfraction += 0.1;\n }\n }\n double end = gettm();\n\n // print results\n printf(\"\\n Simulation time : %.2f s\\n\", end-start);\n printf(\" Time per step : %.3f ms\\n\", 1000.0*(end-start)/mjMAX(1,steps));\n printf(\" Contacts per step : %d\\n\", contacts/mjMAX(1,steps));\n printf(\" Constraints per step : %d\\n\", constraints/mjMAX(1,steps));\n printf(\" Degrees of freedom : %d\\n\\n\", m->nv);\n\n\tsysidcheck(m, d);\n\n\t// print result\n\t#if STATE_LINEAR == true\n\t\tstrcpy(dfilename, dfilepre);\n\t\tstrcat(dfilename, \"linearization_top.txt\");\n\t\tif ((fop2 = fopen(dfilename, \"wt+\")) != NULL)\n\t\t{\n\t\t\tstr3 = glstr;\n\t\t\tfor (int t = 0; t < 1; t++)\n\t\t\t{\n\t\t\t\tfor (int h = 0; h < NS; h++)\n\t\t\t\t{\n\t\t\t\t\tfor (int d = 0; d < NS + ctrl_num; d++)\n\t\t\t\t\t{\n\t\t\t\t\t\tsprintf(str3, \"%4.8f\", mat[t][h][d]);\n\t\t\t\t\t\tfwrite(str3, 10, 1, fop2);\n\t\t\t\t\t\tfputs(\" \", fop2);\n\t\t\t\t\t}\n\t\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t\t}\n\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t}\n\n\t\t\t// for result checking\n\t\t\tfor (int t = 0; t < NS; t++)\n\t\t\t{\n\t\t\t\tfor (int h = 1; h <= 1; h++)\n\t\t\t\t{\n\t\t\t\t\tsprintf(str3, \"%2.4f\", dx[h][t]);\n\t\t\t\t\tfwrite(str3, 6, 1, fop2);\n\t\t\t\t\tfputs(\" \", fop2);\n\t\t\t\t}\n\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t\tfor (int d = 0; d < 1; d++)\n\t\t\t\t{\n\t\t\t\t\tsprintf(str3, \"%2.4f\", delta_xcs[d][t]);\n\t\t\t\t\tfwrite(str3, 6, 1, fop2);\n\t\t\t\t\tfputs(\" \", fop2);\n\t\t\t\t}\n\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t}\n\t\t\tfputs(\"\\nptb_coef: \", fop2);\n\t\t\tsprintf(str3, \"%2.4f\\n\", ptb_coef);\n\t\t\tfwrite(str3, 6, 1, fop2);\n\t\t\tfclose(fop2);\n\t\t}\n\t#else\n\t\tstrcpy(dfilename, dfilepre);\n\t\tstrcat(dfilename, \"lnr.txt\");\n\t\tif ((fop2 = fopen(dfilename, \"wt+\")) != NULL)\n\t\t{\n\t\t\tstr3 = glstr;\n\t\t\tfor (int t = 0; t < step_max; t++)\n\t\t\t{\n\t\t\t\tfor (int h = 0; h < 12; h++)\n\t\t\t\t{\n\t\t\t\t\tfor (int d = 0; d < 12 + ctrl_num; d++)\n\t\t\t\t\t{\n\t\t\t\t\t\tsprintf(str3, \"%4.8f\", mat[t][h][d]);\n\t\t\t\t\t\tfwrite(str3, 10, 1, fop2);\n\t\t\t\t\t\tfputs(\" \", fop2);\n\t\t\t\t\t}\n\t\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t\t}\n\t\t\t\tfputs(\"\\n\", fop2);\n\t\t\t}\n\n\t\t\t//// for result checking\n\t\t\t//for (int t = 0; t < NS; t++)\n\t\t\t//{\n\t\t\t//\tfor (int h = 1; h <= step_max; h++)\n\t\t\t//\t{\n\t\t\t//\t\tsprintf(str3, \"%2.4f\", dx[h][t]);\n\t\t\t//\t\tfwrite(str3, 6, 1, fop2);\n\t\t\t//\t\tfputs(\" \", fop2);\n\t\t\t//\t}\n\t\t\t//\tfputs(\"\\n\", fop2);\n\t\t\t//\tfor (int d = 0; d < step_max; d++)\n\t\t\t//\t{\n\t\t\t//\t\tsprintf(str3, \"%2.4f\", delta_xcs[d][t]);\n\t\t\t//\t\tfwrite(str3, 6, 1, fop2);\n\t\t\t//\t\tfputs(\" \", fop2);\n\t\t\t//\t}\n\t\t\t//\tfputs(\"\\n\", fop2);\n\t\t\t//\tfputs(\"\\n\", fop2);\n\t\t\t//}\n\t\t\tfputs(\"sysiderr: \", fop2);\n\t\t\tsprintf(str3, \"%2.4f\\n\", sysiderr);\n\t\t\tfwrite(str3, 6, 1, fop2);\n\t\t\tfputs(\"\\nptb_coef: \", fop2);\n\t\t\tsprintf(str3, \"%2.4f\\n\", ptb_coef);\n\t\t\tfwrite(str3, 6, 1, fop2);\n\n\t\t\tfclose(fop2);\n\t\t}\n\n\t\t//// state output\n\t\t//strcpy(dfilename, dfilepre);\n\t\t//strcat(dfilename, \"states.txt\");\n\t\t//if ((fp1 = fopen(dfilename, \"at+\")) != NULL)\n\t\t//{\n\t\t//\tstr3 = glstr;\n\t\t//\tfor (int h = 0; h < NS; h++)\n\t\t//\t{\n\t\t//\t\tfor (int d = 1; d < step_max; d++)\n\t\t//\t\t{\n\t\t//\t\t\tsprintf(str3, \"%4.8f\", state_nominal[d][h]);\n\t\t//\t\t\tfwrite(str3, 10, 1, fp1);\n\t\t//\t\t\tfputs(\" \", fp1);\n\t\t//\t\t}\n\t\t//\t\tfputs(\"\\n\", fp1);\n\t\t//\t}\n\t\t//\tfclose(fp1);\n\t\t//}\n\t#endif\n\t// hold cmd\n\tsystem(\"pause\");\n // finalize\n return finish(0, m, d);\n}\n", "meta": {"hexsha": "33a8989545d8682ef6985fb31caf4b404c7c9277", "size": 21980, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "backup/some old code and slides/sample/sysidpartial.cpp", "max_stars_repo_name": "rwang0417/d2c_mujoco200", "max_stars_repo_head_hexsha": "84609fbb14dc38dadf35193d0c7c4431e6f22913", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-02-24T00:15:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-02T03:20:46.000Z", "max_issues_repo_path": "backup/some old code and slides/sample/sysidpartial.cpp", "max_issues_repo_name": "rwang0417/d2c_mujoco200", "max_issues_repo_head_hexsha": "84609fbb14dc38dadf35193d0c7c4431e6f22913", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "backup/some old code and slides/sample/sysidpartial.cpp", "max_forks_repo_name": "rwang0417/d2c_mujoco200", "max_forks_repo_head_hexsha": "84609fbb14dc38dadf35193d0c7c4431e6f22913", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-08-05T20:21:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-02T03:20:49.000Z", "avg_line_length": 24.8642533937, "max_line_length": 148, "alphanum_fraction": 0.5339854413, "num_tokens": 8831, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.640635854839898, "lm_q2_score": 0.4649015713733885, "lm_q1q2_score": 0.2978326155932026}} {"text": "//---------------------------------------------------------------------------//\n// Copyright (c) 2018-2021 Mikhail Komarov \n// Copyright (c) 2020-2021 Nikita Kaskov \n// Copyright (c) 2020-2021 Ilias Khairullin \n//\n// MIT License\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n//---------------------------------------------------------------------------//\n// @file This module implements two binding commitment schemes used in the Groth16\n// aggregation.\n// The first one is a commitment scheme that commits to a single vector $a$ of\n// length n in the second base group $G_1$ (for example):\n// * it requires a structured SRS $v_1$ of the form $(h,h^u,h^{u^2}, ...\n// ,g^{h^{n-1}})$ with $h \\in G_2$ being a random generator of $G_2$ and $u$ a\n// random scalar (coming from a power of tau ceremony for example)\n// * it requires a second structured SRS $v_2$ of the form $(h,h^v,h^{v^2},\n// ...$ with $v$ being a random scalar different than u (coming from another\n// power of tau ceremony for example)\n// The Commitment is a tuple $(\\prod_{i=0}^{n-1} e(a_i,v_{1,i}),\n// \\prod_{i=0}^{n-1} e(a_i,v_{2,i}))$\n//\n// The second one takes two vectors $a \\in G_1^n$ and $b \\in G_2^n$ and commits\n// to them using a similar approach as above. It requires an additional SRS\n// though:\n// * $v_1$ and $v_2$ stay the same\n// * An additional tuple $w_1 = (g^{u^n},g^{u^{n+1}},...g^{u^{2n-1}})$ and $w_2 =\n// (g^{v^n},g^{v^{n+1},...,g^{v^{2n-1}})$ where $g$ is a random generator of\n// $G_1$\n// The commitment scheme returns a tuple:\n// * $\\prod_{i=0}^{n-1} e(a_i,v_{1,i})e(w_{1,i},b_i)$\n// * $\\prod_{i=0}^{n-1} e(a_i,v_{2,i})e(w_{2,i},b_i)$\n//\n// The second commitment scheme enables to save some KZG verification in the\n// verifier of the Groth16 verification protocol since we pack two vectors in\n// one commitment.\n\n#ifndef CRYPTO3_R1CS_GG_PPZKSNARK_AGGREGATE_IPP2_COMMITMENT_HPP\n#define CRYPTO3_R1CS_GG_PPZKSNARK_AGGREGATE_IPP2_COMMITMENT_HPP\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \n\n#include \n\nnamespace nil {\n namespace crypto3 {\n namespace zk {\n namespace snark {\n /// Both commitment outputs a pair of $F_q^k$ element.\n template\n using r1cs_gg_ppzksnark_ipp2_commitment_output =\n std::pair;\n\n /// Key is a generic commitment key that is instantiated with g and h as basis,\n /// and a and b as powers.\n template\n struct r1cs_gg_ppzksnark_ipp2_commitment_key {\n typedef GroupType group_type;\n typedef typename group_type::curve_type curve_type;\n typedef typename curve_type::scalar_field_type field_type;\n\n typedef typename group_type::value_type group_value_type;\n typedef typename field_type::value_type field_value_type;\n\n /// Exponent is a\n std::vector a;\n /// Exponent is b\n std::vector b;\n\n /// Returns true if commitment keys have the exact required length.\n /// It is necessary for the IPP scheme to work that commitment\n /// key have the exact same number of arguments as the number of proofs to\n /// aggregate.\n inline bool has_correct_len(std::size_t n) const {\n return a.size() == n && n == b.size();\n }\n\n /// Returns both vectors scaled by the given vector entrywise.\n /// In other words, it returns $\\{v_i^{s_i}\\}$\n template<\n typename InputIterator,\n typename ValueType = typename std::iterator_traits::value_type,\n typename std::enable_if::value, bool>::type = true>\n r1cs_gg_ppzksnark_ipp2_commitment_key scale(InputIterator s_first,\n InputIterator s_last) const {\n BOOST_ASSERT(has_correct_len(std::distance(s_first, s_last)));\n\n r1cs_gg_ppzksnark_ipp2_commitment_key result;\n std::for_each(boost::make_zip_iterator(boost::make_tuple(s_first, a.begin(), b.begin())),\n boost::make_zip_iterator(boost::make_tuple(s_last, a.end(), b.end())),\n [&](const boost::tuple &t) {\n result.a.emplace_back(t.template get<1>() * t.template get<0>());\n result.b.emplace_back(t.template get<2>() * t.template get<0>());\n });\n\n return result;\n }\n\n /// Returns the left and right commitment key part. It makes copy.\n std::pair,\n r1cs_gg_ppzksnark_ipp2_commitment_key>\n split(std::size_t at) const {\n BOOST_ASSERT(a.size() == b.size());\n BOOST_ASSERT(at > 0 && at < a.size());\n\n r1cs_gg_ppzksnark_ipp2_commitment_key result_l;\n r1cs_gg_ppzksnark_ipp2_commitment_key result_r;\n\n auto a_it = a.begin();\n auto b_it = b.begin();\n while (a_it != a.begin() + at && b_it != b.begin() + at) {\n result_l.a.emplace_back(*a_it);\n result_l.b.emplace_back(*b_it);\n ++a_it;\n ++b_it;\n }\n while (a_it != a.end() && b_it != b.end()) {\n result_r.a.emplace_back(*a_it);\n result_r.b.emplace_back(*b_it);\n ++a_it;\n ++b_it;\n }\n\n return std::make_pair(result_l, result_r);\n }\n\n /// Takes a left and right commitment key and returns a commitment\n /// key $left \\circ right^{scale} = (left_i*right_i^{scale} ...)$. This is\n /// required step during GIPA recursion.\n r1cs_gg_ppzksnark_ipp2_commitment_key\n compress(const r1cs_gg_ppzksnark_ipp2_commitment_key &right,\n const field_value_type &scale) const {\n BOOST_ASSERT(a.size() == right.a.size());\n BOOST_ASSERT(b.size() == right.b.size());\n BOOST_ASSERT(a.size() == b.size());\n\n r1cs_gg_ppzksnark_ipp2_commitment_key result;\n\n std::for_each(\n boost::make_zip_iterator(\n boost::make_tuple(a.begin(), b.begin(), right.a.begin(), right.b.begin())),\n boost::make_zip_iterator(boost::make_tuple(a.end(), b.end(), right.a.end(), right.b.end())),\n [&](const boost::tuple &t) {\n result.a.emplace_back(t.template get<0>() + t.template get<2>() * scale);\n result.b.emplace_back(t.template get<1>() + t.template get<3>() * scale);\n });\n\n return result;\n }\n\n /// Returns the first values in the vector of v1 and v2 (respectively\n /// w1 and w2). When commitment key is of size one, it's a proxy to get the\n /// final values.\n std::pair first() const {\n return std::make_pair(a.front(), b.front());\n }\n };\n\n /// Commitment key used by the \"single\" commitment on G1 values as\n /// well as in the \"pair\" commitment.\n /// It contains $\\{h^a^i\\}_{i=1}^n$ and $\\{h^b^i\\}_{i=1}^n$\n template\n using r1cs_gg_ppzksnark_ipp2_vkey = r1cs_gg_ppzksnark_ipp2_commitment_key;\n\n /// Commitment key used by the \"pair\" commitment. Note the sequence of\n /// powers starts at $n$ already.\n /// It contains $\\{g^{a^{n+i}}\\}_{i=1}^n$ and $\\{g^{b^{n+i}}\\}_{i=1}^n$\n template\n using r1cs_gg_ppzksnark_ipp2_wkey = r1cs_gg_ppzksnark_ipp2_commitment_key;\n\n template\n struct r1cs_gg_ppzksnark_ipp2_commitment {\n typedef CurveType curve_type;\n typedef typename curve_type::pairing pairing;\n\n typedef r1cs_gg_ppzksnark_ipp2_wkey wkey_type;\n typedef r1cs_gg_ppzksnark_ipp2_vkey vkey_type;\n\n typedef typename wkey_type::group_value_type g1_value_type;\n typedef typename vkey_type::group_value_type g2_value_type;\n typedef typename curve_type::gt_type::value_type gt_value_type;\n\n typedef r1cs_gg_ppzksnark_ipp2_commitment_output output_type;\n\n /// Commits to a tuple of G1 vector and G2 vector in the following way:\n /// $T = \\prod_{i=0}^n e(A_i, v_{1,i})e(B_i,w_{1,i})$\n /// $U = \\prod_{i=0}^n e(A_i, v_{2,i})e(B_i,w_{2,i})$\n /// Output is $(T,U)$\n template::value_type,\n typename ValueType2 = typename std::iterator_traits::value_type,\n typename std::enable_if::value, bool>::type = true,\n typename std::enable_if::value, bool>::type = true>\n static output_type pair(const vkey_type &vkey, const wkey_type &wkey, InputG1Iterator a_first,\n InputG1Iterator a_last, InputG2Iterator b_first, InputG2Iterator b_last) {\n BOOST_ASSERT(vkey.has_correct_len(std::distance(a_first, a_last)));\n BOOST_ASSERT(wkey.has_correct_len(std::distance(b_first, b_last)));\n BOOST_ASSERT(std::distance(a_first, a_last) == std::distance(b_first, b_last));\n\n // (A * v)\n gt_value_type t1 = gt_value_type::one();\n std::for_each(boost::make_zip_iterator(boost::make_tuple(a_first, vkey.a.begin())),\n boost::make_zip_iterator(boost::make_tuple(a_last, vkey.a.end())),\n [&](const boost::tuple &t) {\n t1 = t1 * algebra::pair(t.template get<0>(), t.template get<1>());\n });\n\n // (B * v)\n gt_value_type t2 = gt_value_type::one();\n std::for_each(boost::make_zip_iterator(boost::make_tuple(wkey.a.begin(), b_first)),\n boost::make_zip_iterator(boost::make_tuple(wkey.a.end(), b_last)),\n [&](const boost::tuple &t) {\n t2 = t2 * algebra::pair(t.template get<0>(), t.template get<1>());\n });\n\n gt_value_type u1 = gt_value_type::one();\n std::for_each(boost::make_zip_iterator(boost::make_tuple(a_first, vkey.b.begin())),\n boost::make_zip_iterator(boost::make_tuple(a_last, vkey.b.end())),\n [&](const boost::tuple &t) {\n u1 = u1 * algebra::pair(t.template get<0>(), t.template get<1>());\n });\n\n gt_value_type u2 = gt_value_type::one();\n std::for_each(boost::make_zip_iterator(boost::make_tuple(wkey.b.begin(), b_first)),\n boost::make_zip_iterator(boost::make_tuple(wkey.b.end(), b_last)),\n [&](const boost::tuple &t) {\n u2 = u2 * algebra::pair(t.template get<0>(), t.template get<1>());\n });\n\n // (A * v)(w * B)\n return std::make_pair(algebra::final_exponentiation(t1 * t2),\n algebra::final_exponentiation(u1 * u2));\n }\n\n /// Commits to a single vector of G1 elements in the following way:\n /// $T = \\prod_{i=0}^n e(A_i, v_{1,i})$\n /// $U = \\prod_{i=0}^n e(A_i, v_{2,i})$\n /// Output is $(T,U)$\n template::value_type,\n typename std::enable_if::value, bool>::type = true>\n static output_type single(const vkey_type &vkey, InputG1Iterator a_first, InputG1Iterator a_last) {\n BOOST_ASSERT(vkey.has_correct_len(std::distance(a_first, a_last)));\n\n gt_value_type t1 = gt_value_type::one();\n std::for_each(boost::make_zip_iterator(boost::make_tuple(a_first, vkey.a.begin())),\n boost::make_zip_iterator(boost::make_tuple(a_last, vkey.a.end())),\n [&](const boost::tuple &t) {\n t1 = t1 * algebra::pair(t.template get<0>(), t.template get<1>());\n });\n\n gt_value_type u1 = gt_value_type::one();\n std::for_each(boost::make_zip_iterator(boost::make_tuple(a_first, vkey.b.begin())),\n boost::make_zip_iterator(boost::make_tuple(a_last, vkey.b.end())),\n [&](const boost::tuple &t) {\n u1 = u1 * algebra::pair(t.template get<0>(), t.template get<1>());\n });\n\n return std::make_pair(algebra::final_exponentiation(t1),\n algebra::final_exponentiation(u1));\n }\n };\n } // namespace snark\n } // namespace zk\n } // namespace crypto3\n} // namespace nil\n\n#endif // CRYPTO3_R1CS_GG_PPZKSNARK_AGGREGATE_IPP2_COMMITMENT_HPP\n", "meta": {"hexsha": "e990c68d81032ab84bd2cf01cb1d3606640b68d3", "size": 17578, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "snark-logic/libs-source/zk/include/nil/crypto3/zk/snark/schemes/ppzksnark/r1cs_gg_ppzksnark/ipp2/commitment.hpp", "max_stars_repo_name": "idealatom/podlodkin-freeton-year-control", "max_stars_repo_head_hexsha": "6aa96e855fe065c9a75c76da976a87fe2d1668e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "snark-logic/libs-source/zk/include/nil/crypto3/zk/snark/schemes/ppzksnark/r1cs_gg_ppzksnark/ipp2/commitment.hpp", "max_issues_repo_name": "idealatom/podlodkin-freeton-year-control", "max_issues_repo_head_hexsha": "6aa96e855fe065c9a75c76da976a87fe2d1668e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "snark-logic/libs-source/zk/include/nil/crypto3/zk/snark/schemes/ppzksnark/r1cs_gg_ppzksnark/ipp2/commitment.hpp", "max_forks_repo_name": "idealatom/podlodkin-freeton-year-control", "max_forks_repo_head_hexsha": "6aa96e855fe065c9a75c76da976a87fe2d1668e6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-09-15T20:27:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-15T20:27:27.000Z", "avg_line_length": 59.586440678, "max_line_length": 120, "alphanum_fraction": 0.5289566504, "num_tokens": 3784, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO\n\n", "lm_q1_score": 0.7662936430859597, "lm_q2_score": 0.38861802670584894, "lm_q1q2_score": 0.2977955234533018}} {"text": "// ---------------------------------------------------------------------\n//\n// Copyright (c) 2018 - 2021 by the IBAMR developers\n// All rights reserved.\n//\n// This file is part of IBAMR.\n//\n// IBAMR is free software and is distributed under the 3-clause BSD\n// license. The full text of the license can be found in the file\n// COPYRIGHT at the top level directory of IBAMR.\n//\n// ---------------------------------------------------------------------\n\n/////////////////////////////// INCLUDES /////////////////////////////////////\n\n#include \"ibtk/FECache.h\"\n#include \"ibtk/QuadratureCache.h\"\n#include \"ibtk/libmesh_utilities.h\"\n\n#include \"tbox/Utilities.h\"\n\n#if LIBMESH_VERSION_LESS_THAN(1, 2, 0)\n#include \"libmesh/mesh_tools.h\"\n#else\n#include \"libmesh/bounding_box.h\"\n#endif\n#include \"libmesh/dof_map.h\"\n#include \"libmesh/elem.h\"\n#include \"libmesh/enum_elem_type.h\"\n#include \"libmesh/enum_order.h\"\n#include \"libmesh/enum_quadrature_type.h\"\n#include \"libmesh/explicit_system.h\"\n#include \"libmesh/fem_context.h\"\n#include \"libmesh/id_types.h\"\n#include \"libmesh/libmesh_config.h\"\n#include \"libmesh/mesh_base.h\"\n#include \"libmesh/node.h\"\n#include \"libmesh/numeric_vector.h\"\n#include \"libmesh/parallel.h\"\n#include \"libmesh/petsc_vector.h\"\n#include \"libmesh/point.h\"\n#include \"libmesh/quadrature.h\"\n#include \"libmesh/system.h\"\n#include \"libmesh/type_vector.h\"\n#include \"libmesh/variant_filter_iterator.h\"\n\n#include \n\nIBTK_DISABLE_EXTRA_WARNINGS\n#include \nIBTK_ENABLE_EXTRA_WARNINGS\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/////////////////////////////// NAMESPACE ////////////////////////////////////\n\nnamespace IBTK\n{\n/////////////////////////////// STATIC ///////////////////////////////////////\n\n/////////////////////////////// PUBLIC ///////////////////////////////////////\nvoid\nsetup_system_vectors(libMesh::EquationSystems* equation_systems,\n const std::vector& system_names,\n const std::vector& vector_names,\n const bool from_restart)\n{\n for (const std::string& system_name : system_names)\n {\n TBOX_ASSERT(equation_systems->has_system(system_name));\n libMesh::System& system = equation_systems->get_system(system_name);\n for (const std::string& vector_name : vector_names)\n {\n setup_system_vector(system, vector_name, from_restart);\n if (vector_name == \"RHS Vector\")\n {\n auto* explicit_system = dynamic_cast(&system);\n if (!explicit_system)\n {\n TBOX_ERROR(\n \"You are attempting to add a RHS vector to a libMesh system that does not have one (i.e., it \"\n \"does not inherit from ExplicitSystem).\");\n }\n else\n {\n explicit_system->rhs = &system.get_vector(\"RHS Vector\");\n }\n }\n }\n }\n}\n\nvoid\nsetup_system_vector(libMesh::System& system, const std::string& vector_name, const bool from_restart)\n{\n std::unique_ptr > clone_vector;\n if (from_restart)\n {\n libMesh::NumericVector* current = system.request_vector(vector_name);\n if (current != nullptr)\n {\n clone_vector = current->clone();\n }\n }\n system.remove_vector(vector_name);\n system.add_vector(vector_name, /*projections*/ true, /*type*/ libMesh::GHOSTED);\n\n if (clone_vector != nullptr)\n {\n const auto& parallel_vector = dynamic_cast&>(*clone_vector);\n auto& ghosted_vector = dynamic_cast&>(system.get_vector(vector_name));\n TBOX_ASSERT(parallel_vector.size() == ghosted_vector.size());\n TBOX_ASSERT(parallel_vector.local_size() == ghosted_vector.local_size());\n ghosted_vector = parallel_vector;\n ghosted_vector.close();\n }\n}\n\nvoid\napply_transposed_constraint_matrix(const libMesh::DofMap& dof_map, libMesh::PetscVector& rhs)\n{\n std::vector dofs;\n std::vector values_to_add;\n // loop over constraints and do the action of C^T b\n for (auto it = dof_map.constraint_rows_begin(); it != dof_map.constraint_rows_end(); ++it)\n {\n const std::pair& constraint = *it;\n const libMesh::dof_id_type constrained_dof = constraint.first;\n // only resolve constraints if the DoF is locally owned\n if (dof_map.first_dof() <= constrained_dof && constrained_dof < dof_map.end_dof())\n {\n for (const std::pair& pair : constraint.second)\n {\n dofs.push_back(pair.first);\n values_to_add.push_back(pair.second * rhs(constrained_dof));\n }\n }\n }\n\n // If we use ghosted RHSs then we cannot use VecSetValues because we are\n // using a replacement for VecStash. Hence do some somewhat ugly\n // transformations in that case to sum into ghost regions:\n if (rhs.type() == libMesh::GHOSTED)\n {\n // Calling operator() above puts the vector in read-only mode, which\n // has to be restored before we can write to it\n rhs.restore_array();\n // At this point rhs contains the full set of ghost data (which we\n // needed for constraint resolution). However, we now want to reuse\n // the ghost region to sum the values from constraint resolution onto\n // their owning processes. Hence we must clear the ghost data and then\n // do another parallel reduction.\n const PetscInt local_size_without_ghosts = rhs.local_size();\n Vec loc_vec = nullptr;\n // we also need the size of the ghost region, which is surprisingly\n // difficult to get\n int ierr = VecGhostGetLocalForm(rhs.vec(), &loc_vec);\n IBTK_CHKERRQ(ierr);\n PetscInt local_size_with_ghosts = -1;\n ierr = VecGetSize(loc_vec, &local_size_with_ghosts);\n IBTK_CHKERRQ(ierr);\n ierr = VecGhostRestoreLocalForm(rhs.vec(), &loc_vec);\n IBTK_CHKERRQ(ierr);\n\n double* const vec_array = rhs.get_array();\n std::fill(vec_array + local_size_without_ghosts, vec_array + local_size_with_ghosts, 0.0);\n for (std::size_t i = 0; i < dofs.size(); ++i)\n {\n const PetscInt index = rhs.map_global_to_local_index(dofs[i]);\n vec_array[index] += values_to_add[i];\n }\n rhs.restore_array();\n }\n else\n {\n rhs.add_vector(values_to_add.data(), dofs);\n }\n}\n\nquadrature_key_type\ngetQuadratureKey(const libMesh::QuadratureType quad_type,\n libMesh::Order order,\n const bool use_adaptive_quadrature,\n const double point_density,\n const bool allow_rules_with_negative_weights,\n const libMesh::Elem* const elem,\n const boost::multi_array& X_node,\n const double dx_min)\n{\n const libMesh::ElemType elem_type = elem->type();\n#ifndef NDEBUG\n TBOX_ASSERT(elem->p_level() == 0); // higher levels are not implemented\n#endif\n if (use_adaptive_quadrature)\n {\n const double hmax = get_max_edge_length(elem, X_node);\n int npts = int(std::ceil(point_density * hmax / dx_min));\n if (npts < 3)\n {\n if (elem->default_order() == libMesh::FIRST)\n npts = 2;\n else\n npts = 3;\n }\n switch (quad_type)\n {\n case libMesh::QGAUSS:\n order = static_cast(std::min(2 * npts - 1, static_cast(libMesh::FORTYTHIRD)));\n break;\n case libMesh::QGRID:\n order = static_cast(npts);\n break;\n default:\n TBOX_ERROR(\"IBTK::getQuadratureKey():\\n\"\n << \" adaptive quadrature rules are available only for quad_type = QGAUSS \"\n \"or QGRID\\n\");\n }\n }\n\n return std::make_tuple(elem_type, quad_type, order, allow_rules_with_negative_weights);\n}\n\nvoid\nwrite_elem_partitioning(const std::string& file_name, const libMesh::System& position_system)\n{\n const int current_rank = position_system.comm().rank();\n const unsigned int position_system_n = position_system.number();\n const libMesh::NumericVector& local_position = *position_system.solution.get();\n const libMesh::MeshBase& mesh = position_system.get_mesh();\n const unsigned int spacedim = mesh.spatial_dimension();\n // TODO: there is something wrong with the way we set up the ghost data in\n // the position vectors: not all locally owned nodes are, in fact, locally\n // available. Get around this by localizing first. Since all processes\n // write to the same file this isn't the worst bottleneck in this\n // function, anyway.\n std::vector position(local_position.size());\n local_position.localize(position);\n std::stringstream current_processor_output;\n\n const auto end_elem = mesh.local_elements_end();\n for (auto elem = mesh.local_elements_begin(); elem != end_elem; ++elem)\n {\n const unsigned int n_nodes = (*elem)->n_nodes();\n libMesh::Point center;\n // TODO: this is a bit crude: if we use isoparametric elements (e.g.,\n // Tri6) then this is not a very accurate representation of the center\n // of the element. We should replace this with something more accurate.\n for (unsigned int node_n = 0; node_n < n_nodes; ++node_n)\n {\n const libMesh::Node& node = (*elem)->node_ref(node_n);\n TBOX_ASSERT(node.n_vars(position_system_n) == spacedim);\n for (unsigned int d = 0; d < spacedim; ++d)\n {\n center(d) += position[node.dof_number(position_system_n, d, 0)];\n }\n }\n center *= 1.0 / n_nodes;\n\n for (unsigned int d = 0; d < spacedim; ++d)\n {\n current_processor_output << center(d) << ',';\n }\n if (spacedim == 2)\n {\n current_processor_output << 0.0 << ',';\n }\n current_processor_output << current_rank << '\\n';\n }\n\n // clear the file before we append to it\n if (current_rank == 0)\n {\n std::remove(file_name.c_str());\n }\n const int n_processes = position_system.comm().size();\n for (int rank = 0; rank < n_processes; ++rank)\n {\n if (rank == current_rank)\n {\n std::ofstream out(file_name, std::ios_base::app);\n if (rank == 0)\n {\n out << \"x,y,z,r\\n\";\n }\n out << current_processor_output.rdbuf();\n }\n position_system.comm().barrier();\n }\n}\n\nvoid\nwrite_node_partitioning(const std::string& file_name, const libMesh::System& position_system)\n{\n const int current_rank = position_system.comm().rank();\n const unsigned int position_system_n = position_system.number();\n const libMesh::NumericVector& local_position = *position_system.solution.get();\n const libMesh::MeshBase& mesh = position_system.get_mesh();\n const unsigned int spacedim = mesh.spatial_dimension();\n\n // TODO: there is something wrong with the way we set up the ghost data in\n // the position vectors: not all locally owned nodes are, in fact,\n // locally available. Get around this by localizing first. Since all\n // processes write to the same file this isn't the worst bottleneck in\n // this function, anyway.\n std::vector position(local_position.size());\n local_position.localize(position);\n std::stringstream current_processor_output;\n\n const auto end_node = mesh.local_nodes_end();\n for (auto node_it = mesh.local_nodes_begin(); node_it != end_node; ++node_it)\n {\n const libMesh::Node* const node = *node_it;\n if (node->n_vars(position_system_n))\n {\n TBOX_ASSERT(node->n_vars(position_system_n) == spacedim);\n for (unsigned int d = 0; d < spacedim; ++d)\n {\n current_processor_output << position[node->dof_number(position_system_n, d, 0)] << ',';\n }\n if (spacedim == 2)\n {\n current_processor_output << 0.0 << ',';\n }\n current_processor_output << current_rank << '\\n';\n }\n }\n\n // clear the file before we append to it\n if (current_rank == 0)\n {\n std::remove(file_name.c_str());\n }\n const int n_processes = position_system.comm().size();\n for (int rank = 0; rank < n_processes; ++rank)\n {\n if (rank == current_rank)\n {\n std::ofstream out(file_name, std::ios_base::app);\n if (rank == 0)\n {\n out << \"x,y,z,r\\n\";\n }\n out << current_processor_output.rdbuf();\n }\n position_system.comm().barrier();\n }\n}\n\nstd::vector\nget_local_element_bounding_boxes(const libMesh::MeshBase& mesh,\n const libMesh::System& X_system,\n const libMesh::QuadratureType quad_type,\n const libMesh::Order quad_order,\n const bool use_adaptive_quadrature,\n const double point_density,\n bool allow_rules_with_negative_weights,\n const double patch_dx_min)\n{\n const unsigned int dim = mesh.mesh_dimension();\n const unsigned int spacedim = mesh.spatial_dimension();\n TBOX_ASSERT(spacedim == NDIM);\n const unsigned int X_sys_num = X_system.number();\n auto X_ghost_vec_ptr = X_system.current_local_solution->zero_clone();\n auto& X_ghost_vec = dynamic_cast&>(*X_ghost_vec_ptr);\n X_ghost_vec = *X_system.solution;\n\n std::vector bboxes;\n\n std::vector > dof_indices(NDIM);\n boost::multi_array X_node;\n QuadratureCache quad_cache(dim);\n FECache fe_cache(dim, X_system.get_dof_map().variable_type(0), update_phi);\n using quad_key_type = quadrature_key_type;\n const auto el_begin = mesh.local_elements_begin();\n const auto el_end = mesh.local_elements_end();\n for (auto el_it = el_begin; el_it != el_end; ++el_it)\n {\n // 0. Set up bounding box\n bboxes.emplace_back();\n auto& box = bboxes.back();\n libMesh::Point& lower_bound = box.first;\n libMesh::Point& upper_bound = box.second;\n for (unsigned int d = 0; d < LIBMESH_DIM; ++d)\n {\n lower_bound(d) = std::numeric_limits::max();\n upper_bound(d) = -std::numeric_limits::max();\n }\n\n // As mentioned in the documentation of this function we do not set up\n // bounding boxes for inactive elements\n if (!(*el_it)->active()) continue;\n\n // 1. extract node locations\n const libMesh::Elem* const elem = *el_it;\n const unsigned int n_nodes = elem->n_nodes();\n for (unsigned int d = 0; d < NDIM; ++d) dof_indices[d].clear();\n\n for (unsigned int k = 0; k < n_nodes; ++k)\n {\n const libMesh::Node* const node = elem->node_ptr(k);\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n TBOX_ASSERT(node->n_dofs(X_sys_num, d) == 1);\n dof_indices[d].push_back(node->dof_number(X_sys_num, d, 0));\n }\n }\n get_values_for_interpolation(X_node, X_ghost_vec, dof_indices);\n\n // 2. compute mapped quadrature points in the deformed configuration\n const quad_key_type key = getQuadratureKey(quad_type,\n quad_order,\n use_adaptive_quadrature,\n point_density,\n allow_rules_with_negative_weights,\n elem,\n X_node,\n patch_dx_min);\n libMesh::QBase& quadrature = quad_cache[key];\n libMesh::FEBase& fe = fe_cache(key, elem);\n const std::vector >& phi_X = fe.get_phi();\n const std::vector& q_points = quadrature.get_points();\n for (unsigned int qp = 0; qp < q_points.size(); ++qp)\n {\n libMesh::Point mapped_point;\n for (unsigned int k = 0; k < n_nodes; ++k)\n {\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n mapped_point(d) += phi_X[k][qp] * X_node[k][d];\n }\n }\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n lower_bound(d) = std::min(lower_bound(d), mapped_point(d));\n upper_bound(d) = std::max(upper_bound(d), mapped_point(d));\n }\n\n // fill extra dimension with 0.0, which is libMesh's convention\n for (unsigned int d = NDIM; d < LIBMESH_DIM; ++d)\n {\n lower_bound(d) = 0.0;\n upper_bound(d) = 0.0;\n }\n }\n }\n\n return bboxes;\n} // get_local_element_bounding_boxes\n\nstd::vector\nget_local_element_bounding_boxes(const libMesh::MeshBase& mesh, const libMesh::System& X_system)\n{\n const unsigned int spacedim = mesh.spatial_dimension();\n TBOX_ASSERT(spacedim == NDIM);\n const unsigned int X_sys_num = X_system.number();\n auto X_ghost_vec_ptr = X_system.current_local_solution->zero_clone();\n auto& X_ghost_vec = dynamic_cast&>(*X_ghost_vec_ptr);\n X_ghost_vec = *X_system.solution;\n\n std::vector bboxes;\n bboxes.reserve(mesh.n_local_elem());\n\n std::vector dof_indices;\n std::vector X_node;\n const auto el_begin = mesh.local_elements_begin();\n const auto el_end = mesh.local_elements_end();\n for (auto el_it = el_begin; el_it != el_end; ++el_it)\n {\n const libMesh::Elem* const elem = *el_it;\n const unsigned int n_nodes = elem->n_nodes();\n bboxes.emplace_back();\n auto& box = bboxes.back();\n libMesh::Point& lower_bound = box.first;\n libMesh::Point& upper_bound = box.second;\n for (unsigned int d = 0; d < LIBMESH_DIM; ++d)\n {\n lower_bound(d) = std::numeric_limits::max();\n upper_bound(d) = -std::numeric_limits::max();\n }\n\n // As mentioned in the documentation of this function we do not set up\n // bounding boxes for inactive elements\n if (!(*el_it)->active()) continue;\n\n dof_indices.clear();\n for (unsigned int k = 0; k < n_nodes; ++k)\n {\n const libMesh::Node* const node = elem->node_ptr(k);\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n TBOX_ASSERT(node->n_dofs(X_sys_num, d) == 1);\n dof_indices.push_back(node->dof_number(X_sys_num, d, 0));\n }\n }\n\n X_node.resize(dof_indices.size());\n X_ghost_vec.get(dof_indices, X_node.data());\n for (unsigned int k = 0; k < n_nodes; ++k)\n {\n for (unsigned int d = 0; d < NDIM; ++d)\n {\n const double& X = X_node[k * NDIM + d];\n lower_bound(d) = std::min(lower_bound(d), X);\n upper_bound(d) = std::max(upper_bound(d), X);\n }\n }\n\n // fill extra dimension with 0.0, which is libMesh's convention\n for (unsigned int d = NDIM; d < LIBMESH_DIM; ++d)\n {\n lower_bound(d) = 0.0;\n upper_bound(d) = 0.0;\n }\n }\n\n return bboxes;\n} // get_local_element_bounding_boxes\n\nstd::vector\nget_global_element_bounding_boxes(const libMesh::MeshBase& mesh,\n const std::vector& local_bboxes)\n{\n const std::size_t n_elem = mesh.n_elem();\n std::vector flattened_bboxes(2 * LIBMESH_DIM * n_elem);\n std::size_t elem_n = 0;\n const auto el_begin = mesh.local_elements_begin();\n const auto el_end = mesh.local_elements_end();\n for (auto el_it = el_begin; el_it != el_end; ++el_it)\n {\n const auto id = (*el_it)->id();\n TBOX_ASSERT((2 * id + 2) * LIBMESH_DIM - 1 < flattened_bboxes.size());\n for (unsigned int d = 0; d < LIBMESH_DIM; ++d)\n {\n flattened_bboxes[2 * id * LIBMESH_DIM + d] = local_bboxes[elem_n].first(d);\n flattened_bboxes[(2 * id + 1) * LIBMESH_DIM + d] = local_bboxes[elem_n].second(d);\n }\n ++elem_n;\n }\n const int ierr = MPI_Allreduce(\n MPI_IN_PLACE, flattened_bboxes.data(), flattened_bboxes.size(), MPI_DOUBLE, MPI_SUM, mesh.comm().get());\n TBOX_ASSERT(ierr == 0);\n\n std::vector global_bboxes(n_elem);\n for (unsigned int e = 0; e < n_elem; ++e)\n {\n for (unsigned int d = 0; d < LIBMESH_DIM; ++d)\n {\n global_bboxes[e].first(d) = flattened_bboxes[2 * e * LIBMESH_DIM + d];\n global_bboxes[e].second(d) = flattened_bboxes[(2 * e + 1) * LIBMESH_DIM + d];\n }\n }\n return global_bboxes;\n} // get_local_element_bounding_boxes\n\nstd::vector\nget_global_element_bounding_boxes(const libMesh::MeshBase& mesh, const libMesh::System& X_system)\n{\n static_assert(NDIM <= LIBMESH_DIM,\n \"NDIM should be no more than LIBMESH_DIM for this function to \"\n \"work correctly.\");\n return get_global_element_bounding_boxes(mesh, get_local_element_bounding_boxes(mesh, X_system));\n} // get_global_element_bounding_boxes\n//////////////////////////////////////////////////////////////////////////////\n\n} // namespace IBTK\n\n//////////////////////////////////////////////////////////////////////////////\n", "meta": {"hexsha": "c2f315c391f7acdfa2f04a56498f514ced2c2e54", "size": 22405, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ibtk/src/utilities/libmesh_utilities.cpp", "max_stars_repo_name": "akashdhruv/IBAMR", "max_stars_repo_head_hexsha": "a2b47946d795fb5a40c181b43e44a6ec387585a9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 264.0, "max_stars_repo_stars_event_min_datetime": "2015-01-04T12:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T13:10:37.000Z", "max_issues_repo_path": "ibtk/src/utilities/libmesh_utilities.cpp", "max_issues_repo_name": "akashdhruv/IBAMR", "max_issues_repo_head_hexsha": "a2b47946d795fb5a40c181b43e44a6ec387585a9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1057.0, "max_issues_repo_issues_event_min_datetime": "2015-04-27T04:27:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T13:14:59.000Z", "max_forks_repo_path": "ibtk/src/utilities/libmesh_utilities.cpp", "max_forks_repo_name": "drwells/IBAMR", "max_forks_repo_head_hexsha": "0ceda3873405a35da4888c99e7d2b24d132f9071", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 126.0, "max_forks_repo_forks_event_min_datetime": "2015-02-13T15:36:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T21:59:50.000Z", "avg_line_length": 38.7629757785, "max_line_length": 118, "alphanum_fraction": 0.5887971435, "num_tokens": 5200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5774953651858117, "lm_q2_score": 0.5156199157230156, "lm_q1q2_score": 0.29776811152754035}} {"text": "// $Id$\n/*\n * This is an extensive modification by Greg Landrum of\n * pieces from several files in the vflib-2.0 distribution\n *\n * The initial version of the modifications was completed\n * in April 2009.\n *\n * the original author of the vflib files is:\n * Author: P. Foggia\n * http://amalfi.dis.unina.it/graph/db/vflib-2.0/doc/vflib.html\n *\n */\n#include \n#include \n#include \n#include \n\n#ifndef __BGL_VF2_SUB_STATE_H__\n#define __BGL_VF2_SUB_STATE_H__\n\nnamespace boost{\n namespace detail {\n typedef unsigned short node_id;\n const node_id NULL_NODE=0xFFFF;\n struct NodeInfo {\n node_id id;\n node_id in;\n node_id out;\n };\n\n /**\n * The ordering by in/out degree\n */\n static bool nodeInfoComp1(const NodeInfo &a, const NodeInfo &b) {\n if(a.out < b.out) return true;\n if(a.out > b.out) return false;\n if(a.in < b.in) return true;\n if(a.in > b.in) return false;\n return false;\n }\n\n /**\n * The ordering by frequency/valence.\n * The frequency is in the out field, the valence in `in'.\n */\n static int nodeInfoComp2(const NodeInfo &a, const NodeInfo &b) {\n if (!a.in && b.in ) return 1;\n if (a.in && !b.in) return -1;\n if (a.out < b.out) return -1;\n if (a.out > b.out) return 1;\n if( a.in < b.in ) return -1;\n if (a.in > b.in) return 1;\n return 0;\n }\n\n template \n VertexDescr getOtherIdx(const Graph &g,const EdgeDescr &edge,const VertexDescr &vertex) {\n VertexDescr tmp=boost::source(edge,g);\n if(tmp==vertex){\n tmp=boost::target(edge,g);\n }\n return tmp;\n }\n \n /*----------------------------------------------------\n * Sorts the nodes of a graphs, returning a \n * heap-allocated vector (using new) with the node ids\n * in the proper orders.\n * The sorting criterion takes into account:\n * 1 - The number of nodes with the same in/out \n * degree.\n * 2 - The valence of the nodes.\n * The nodes at the beginning of the vector are\n * the most singular, from which the matching should\n * start.\n *--------------------------------------------------*/\n template \n node_id* SortNodesByFrequency(const Graph *g) {\n std::vector vect;\n vect.reserve(boost::num_vertices(*g));\n typename Graph::vertex_iterator bNode,eNode;\n boost::tie(bNode,eNode) = boost::vertices(*g);\n while(bNode!=eNode){\n NodeInfo t;\n t.id=vect.size();\n t.in=boost::out_degree(*bNode,*g);// <- assuming undirected graph\n t.out=boost::out_degree(*bNode,*g); \n vect.push_back(t);\n ++bNode;\n }\n std::sort(vect.begin(),vect.end(),nodeInfoComp1);\n \n unsigned int run=1;\n for(unsigned int i=0; i\n class VF2SubState\n { \n private:\n Graph *g1, *g2;\n VertexCompatible &vc;\n EdgeCompatible &ec;\n MatchChecking &mc;\n unsigned int n1, n2;\n\n unsigned int core_len, orig_core_len;\n unsigned int added_node1;\n unsigned int t1both_len, t2both_len;\n unsigned int t1in_len, t1out_len; \n unsigned int t2in_len, t2out_len; // Core nodes are also counted by these...\n node_id *core_1;\n node_id *core_2;\n node_id *in_1;\n node_id *in_2;\n node_id *out_1;\n node_id *out_2;\n\n node_id *order;\n\n long *share_count;\n int *vs_compared;\n \n public:\n VF2SubState(Graph *ag1, Graph *ag2,\n VertexCompatible &avc,\n EdgeCompatible &aec,\n MatchChecking &amc,\n bool sortNodes=false) : g1(ag1), g2(ag2), vc(avc), ec(aec), mc(amc),\n n1(num_vertices(*ag1)),n2(num_vertices(*ag2)) {\n if (sortNodes){\n order = SortNodesByFrequency(ag1);\n } else {\n order = NULL;\n }\n\n core_len=orig_core_len=0;\n t1both_len=t1in_len=t1out_len=0;\n t2both_len=t2in_len=t2out_len=0;\n\n added_node1=NULL_NODE;\n\n core_1=new node_id[n1];\n core_2=new node_id[n2];\n in_1=new node_id[n1];\n in_2=new node_id[n2];\n out_1=new node_id[n1];\n out_2=new node_id[n2];\n share_count = new long;\n\n for(unsigned int i=0; i();\n *share_count = 1;\n };\n\n VF2SubState(const VF2SubState &state) :\n g1(state.g1), g2(state.g2), vc(state.vc), ec(state.ec), mc(state.mc),\n n1(state.n1),n2(state.n2), order(state.order),vs_compared(state.vs_compared)\n //es_compared(state.es_compared)\n {\n\n core_len=orig_core_len=state.core_len;\n t1in_len=state.t1in_len;\n t1out_len=state.t1out_len;\n t1both_len=state.t1both_len;\n t2in_len=state.t2in_len;\n t2out_len=state.t2out_len;\n t2both_len=state.t2both_len;\n\n added_node1=NULL_NODE;\n\n core_1=state.core_1;\n core_2=state.core_2;\n in_1=state.in_1;\n in_2=state.in_2;\n out_1=state.out_1;\n out_2=state.out_2;\n share_count=state.share_count;\n\n ++(*share_count);\n };\n\n ~VF2SubState(){\n if (-- *share_count == 0) {\n delete [] core_1;\n delete [] core_2;\n delete [] in_1;\n delete [] out_1;\n delete [] in_2;\n delete [] out_2;\n delete share_count;\n delete [] order;\n //delete [] vs_compared;\n //delete es_compared;\n }\n }; \n\n bool IsGoal() { return core_len==n1 ; };\n bool MatchChecks(const node_id c1[],const node_id c2[]){\n return mc(c1,c2);\n };\n bool IsDead() { return n1>n2 || \n t1both_len>t2both_len ||\n t1out_len>t2out_len ||\n t1in_len>t2in_len;\n };\n unsigned int CoreLen() { return core_len; }\n Graph *GetGraph1() { return g1; }\n Graph *GetGraph2() { return g2; }\n\n bool NextPair(node_id *pn1, node_id *pn2,\n node_id prev_n1=NULL_NODE, node_id prev_n2=NULL_NODE){\n if (prev_n1==NULL_NODE)\n prev_n1=0;\n if (prev_n2==NULL_NODE)\n prev_n2=0;\n else\n prev_n2++;\n\n#if 0\n std::cerr<<\" **** np: \"<< prev_n1<<\",\"<core_len && t2both_len>core_len) {\n while (prev_n1core_len && t2out_len>core_len) {\n while (prev_n1core_len && t2in_len>core_len) {\n while (prev_n1core_len && t2both_len>core_len) {\n while (prev_n2core_len && t2out_len>core_len) {\n while (prev_n2core_len && t2in_len>core_len) {\n while (prev_n2size()<\n bool match(int *pn, node_id c1[], node_id c2[], SubState &s)\n {\n if (s.IsGoal() ) { \n s.GetCoreSet(c1, c2);\n if(s.MatchChecks(c1,c2)) {\n *pn=s.CoreLen();\n return true;\n }\n }\n\n if (s.IsDead())\n return false;\n //std::cerr<<\" > match: \"<<*pn<<\" \"<<&s<AddPair(n1, n2);\n found=match(pn, c1, c2, *s1);\n s1->BackTrack();\n delete s1;\n }\n }\n //std::cerr<<\" < returning: \"<\n bool match(node_id c1[], node_id c2[], SubState &s, DoubleBackInsertionSequence &res,\n unsigned int max_results) {\n if (s.IsGoal()){\n s.GetCoreSet(c1, c2);\n if(s.MatchChecks(c1,c2)) {\n typename DoubleBackInsertionSequence::value_type newSeq;\n for(unsigned int i=0;i(c1[i],c2[i]));\n }\n res.push_back(newSeq);\n if(res.size()>=max_results) return true;\n }\n return false;\n }\n\n if (s.IsDead())\n return false;\n\n node_id n1=NULL_NODE, n2=NULL_NODE;\n while (s.NextPair(&n1, &n2, n1, n2)) {\n if (s.IsFeasiblePair(n1, n2)){\n SubState *s1=s.Clone();\n s1->AddPair(n1, n2);\n if (match(c1, c2, *s1,res,max_results)){\n s1->BackTrack(); \n delete s1;\n return true;\n }\n else {\n s1->BackTrack(); \n delete s1;\n }\n }\n }\n return false;\n }\n }; //end of namespace detail\n\n template < class Graph\n , class VertexLabeling // binary predicate\n , class EdgeLabeling // binary predicate\n , class MatchChecking // binary predicate\n , class BackInsertionSequence // contains std::pair\n >\n bool vf2(const Graph &g1,const Graph &g2,\n VertexLabeling& vertex_labeling,\n EdgeLabeling& edge_labeling,\n MatchChecking& match_checking,\n BackInsertionSequence& F){\n detail::VF2SubState s0(&g1,&g2,vertex_labeling,\n edge_labeling,match_checking,false);\n detail::node_id *ni1 = new detail::node_id[num_vertices(g1)];\n detail::node_id *ni2 = new detail::node_id[num_vertices(g2)];\n int n=0;\n \n F.clear();\n F.resize(0);\n if(match(&n,ni1,ni2,s0)){\n for(unsigned int i=0;i(ni1[i],ni2[i]));\n }\n }\n delete [] ni1;\n delete [] ni2;\n \n return !F.empty();\n };\n template < class Graph\n , class VertexLabeling // binary predicate\n , class EdgeLabeling // binary predicate\n , class MatchChecking // binary predicate\n , class DoubleBackInsertionSequence // contains a back insertion sequence\n >\n bool vf2_all(const Graph& g1, const Graph& g2,\n VertexLabeling& vertex_labeling,\n EdgeLabeling& edge_labeling,\n MatchChecking& match_checking,\n DoubleBackInsertionSequence& F,\n unsigned int max_results=1000) {\n detail::VF2SubState s0(&g1,&g2,vertex_labeling,\n edge_labeling,match_checking,false);\n detail::node_id *ni1 = new detail::node_id[num_vertices(g1)];\n detail::node_id *ni2 = new detail::node_id[num_vertices(g2)];\n \n F.clear();\n F.resize(0);\n\n match(ni1,ni2,s0,F,max_results);\n\n delete [] ni1;\n delete [] ni2;\n \n return !F.empty();\n };\n} // end of namespace boost\n#endif\n\n", "meta": {"hexsha": "31b7663d8f7101dc8b94f982f94ef8577fc5c2ff", "size": 21107, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "modified_rdkit/Code/GraphMol/Substruct/vf2.hpp", "max_stars_repo_name": "hjuinj/RDKit_mETKDG", "max_stars_repo_head_hexsha": "b270e765caa61d289e9e33595d4264b156f9062e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-03-30T04:00:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-31T01:32:13.000Z", "max_issues_repo_path": "modified_rdkit/Code/GraphMol/Substruct/vf2.hpp", "max_issues_repo_name": "hjuinj/RDKit_mETKDG", "max_issues_repo_head_hexsha": "b270e765caa61d289e9e33595d4264b156f9062e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-05-23T17:31:04.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-26T06:52:47.000Z", "max_forks_repo_path": "modified_rdkit/Code/GraphMol/Substruct/vf2.hpp", "max_forks_repo_name": "hjuinj/RDKit_mETKDG", "max_forks_repo_head_hexsha": "b270e765caa61d289e9e33595d4264b156f9062e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2020-03-30T04:00:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-25T23:11:52.000Z", "avg_line_length": 31.6921921922, "max_line_length": 129, "alphanum_fraction": 0.5114417018, "num_tokens": 6010, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5774953651858117, "lm_q2_score": 0.5156199157230156, "lm_q1q2_score": 0.29776811152754035}} {"text": "// Ultra fast anagram generator\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nusing std::bitset;\nusing std::cerr;\nusing std::cout;\nusing std::endl;\nusing std::forward;\nusing std::ifstream;\nusing std::ios;\nusing std::nullopt;\nusing std::optional;\nusing std::ostream;\nusing std::ostringstream;\nusing std::pair;\nusing std::string;\nusing std::tie;\nusing std::unordered_map;\nusing std::vector;\n\nusing boost::hash_range;\nusing icu::UnicodeString;\n\ntypedef unsigned __int128 bigint;\n\nnamespace po = boost::program_options;\n\n// total maximum of letters in input\nconstexpr int MAX_LETTERS = 128;\n\ntypedef uint8_t CharIdx;\nconstexpr int MAX_CHARIDX = std::numeric_limits::max();\n\n// first 168 primes\nconstexpr int PRIMES[] = {\n 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,\n 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,\n 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,\n 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,\n 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,\n 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,\n 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,\n 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,\n 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,\n 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,\n 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997\n};\n\n// If the given function returns false, terminate.\ntemplate \nbool forAllAlpha(const UnicodeString &s, Fn &&f) {\n for (int j = 0, je = s.length(); j CharMap;\n\nstatic size_t hash_bigint(const bigint &m) {\n // Let's decide the lowest bits are good enough, even though it's\n // guaranteed we have count(most_common_letter) trailing zero\n // bits.\n return static_cast(m);\n}\n\n// A multiset of characters.\n//\n// The allowable characters are passed in the CharMap, which maps\n// unicode characters to integers starting from 0.\n//\n// To facilitate the required multiset operations, namely subtraction\n// and subset testing, we map a multiset to an integer (which may not\n// fit in a fixed size integer type)\n//\n// product(nth_prime(i)**char_count(i)).\n//\n// Now,\n//\n// * x is a subset of y iff x.num % y.num == 0\n// * x-y maps to integer division.\n//\n// The order of characters is chosen such that the most common\n// characters in the input map to smallest primes, which results in\n// smallest numbers.\nclass CharBag {\npublic:\n static optional fromUString(const UnicodeString &str, const CharMap &charmap);\n static optional fromLowerUString(const UnicodeString &str, const CharMap &charmap);\n static optional fromNativeString(const string &str, const CharMap &charmap) {\n return fromUString(UnicodeString(str.c_str()), charmap);\n }\n const bigint &num() const { return m_num; }\n const int size() const { return m_size; }\n size_t hash() const { return m_hash; }\n\n bool empty() const { return m_size == 0; }\n\n bool isSubsetOf(const CharBag &other) const {\n auto cs_opt = other-*this;\n return (bool)cs_opt;\n }\n\n optional operator-(const CharBag &rhs) const;\n bool operator==(const CharBag &rhs) const;\nprivate:\n CharBag(bigint num, int size) :\n m_num(num), m_size(size), m_hash(compute_hash(m_size, m_num)) {}\n\n static size_t compute_hash(const int &size, const bigint &num) {\n // As a hack to find words faster, we want longer words to map\n // to smaller hashes. Do this by mapping negated size to the\n // high bits of the hash.\n constexpr int bits = std::numeric_limits::digits;\n size_t hi = (~static_cast(size)) << (bits-7);\n size_t lo = hash_bigint(num) & ((size_t(1) << (bits-7)) - 1);\n return hi | lo;\n }\n\n bigint m_num;\n int m_size;\n size_t m_hash;\n};\n\nnamespace std {\n template <> struct hash {\n size_t operator()(const CharBag &cs) const {\n return cs.hash();\n }\n };\n}\n\nbool CharBag::operator==(const CharBag &rhs) const {\n return m_hash == rhs.m_hash && m_num == rhs.m_num;\n}\n\noptional CharBag::operator-(const CharBag &rhs) const {\n if (rhs.m_size > m_size)\n return nullopt;\n\n if (m_size == rhs.m_size && m_num == rhs.m_num)\n return CharBag{bigint(1), 0};\n\n // if (!mpz_divisible_p(m_num.get_mpz_t(), rhs.m_num.get_mpz_t()))\n // return nullopt;\n if (m_num % rhs.m_num != 0)\n return nullopt;\n\n return CharBag{m_num/rhs.m_num, m_size-rhs.m_size};\n}\n\noptional CharBag::fromLowerUString(const UnicodeString &str, const CharMap &charmap) {\n bigint n(1);\n int size = 0;\n\n static_assert(sizeof(PRIMES)/sizeof(PRIMES[0]) >= MAX_LETTERS);\n\n if (forAllAlpha(str, [&n, &size, &charmap](UChar c) {\n auto it = charmap.find(c);\n if (it == charmap.end())\n return false;\n int idx = it->second;\n assert(idx < MAX_LETTERS);\n n *= PRIMES[idx];\n ++size;\n return true;\n })) {\n return CharBag(n, size);\n } else\n return nullopt;\n}\n\noptional CharBag::fromUString(const UnicodeString &str_, const CharMap &charmap) {\n UnicodeString str(str_);\n str.toLower();\n return fromLowerUString(str, charmap);\n}\n\n// [[maybe_unused]]\n// static ostream &operator<<(ostream &os, const CharBag &cs) {\n// return os << \"CharBag{\" << cs.size() << \", \" << cs.num() << \"}\";\n// }\n\n// [[maybe_unused]]\n// static ostream &operator<<(ostream &os, const optional &cs) {\n// if (cs)\n// os << *cs;\n// else\n// os << \"nil\";\n// return os;\n// }\n\n// from https://stackoverflow.com/questions/17074324/\ntemplate \nvoid apply_permutation_in_place(std::vector& vec,\n const std::vector& p) {\n std::vector done(vec.size());\n for (std::size_t i = 0; i < vec.size(); ++i) {\n if (done[i])\n continue;\n done[i] = true;\n std::size_t prev_j = i;\n std::size_t j = p[i];\n while (i != j) {\n std::swap(vec[prev_j], vec[j]);\n done[j] = true;\n prev_j = j;\n j = p[j];\n }\n }\n}\n\nstatic vector slurp(const string &fileName) {\n ifstream ifs(fileName.c_str(), ios::binary | ios::ate);\n\n ifstream::pos_type size = ifs.tellg();\n ifs.seekg(0, ios::beg);\n\n vector bytes(size);\n ifs.read(bytes.data(), size);\n\n return bytes;\n}\n\n// The dictionary words are sorted by length (number of alphabetic\n// characters). This is important, it's used in\n// forAllAnagrams_iter_last().\nstatic pair>, vector> loadDictionary(\n const string &fname, const CharBag &cset, const CharMap &cmap) {\n const auto raw_contents = slurp(fname);\n UnicodeString contents = UnicodeString(raw_contents.data(), raw_contents.size());\n contents.toLower();\n size_t contents_len = contents.length();\n\n vector> words;\n vector charbags;\n unordered_map charbag_map;\n\n size_t count = 0;\n\n size_t line_start = 0;\n while (true) {\n auto newline = contents.indexOf(UChar('\\n'), line_start);\n\n size_t endpos;\n if (newline == -1)\n endpos = contents_len;\n else\n endpos = newline;\n\n auto str_len = endpos - line_start;\n auto line = contents.tempSubString(line_start, str_len);\n if (str_len > 0) {\n optional cs = CharBag::fromLowerUString(line, cmap);\n if (cs && cset - *cs) {\n if (cs->empty())\n continue;\n ++count;\n\n ostringstream line_sstream;\n line_sstream << line;\n\n auto it = charbag_map.find(*cs);\n if (it == charbag_map.end()) {\n words.emplace_back(vector{{line_sstream.str()}});\n charbags.emplace_back(*cs);\n charbag_map[*cs] = words.size()-1;\n } else\n words[it->second].emplace_back(line_sstream.str());\n }\n }\n if (newline == -1)\n break;\n else\n line_start = newline+1;\n }\n\n // Sort the words by charbag hash.\n\n vector hash_sort_order(charbags.size());\n std::iota(hash_sort_order.begin(), hash_sort_order.end(), 0);\n\n std::sort(hash_sort_order.begin(), hash_sort_order.end(),\n [&charbags](int a, int b) { return charbags[a].hash() < charbags[b].hash(); });\n\n apply_permutation_in_place(words, hash_sort_order);\n apply_permutation_in_place(charbags, hash_sort_order);\n\n //cerr << \"Loaded \" << count << \" dictionary words, \" << words.size() << \" distinct.\" << endl;\n return {words, charbags};\n}\n\ntemplate \nvoid forAllAnagrams_iter_last(const vector &dict_charbags,\n const vector &possible_charbags,\n const CharBag &charbag, Fn &&f,\n vector &words, size_t start_idx) {\n size_t required_hash = charbag.hash();\n\n auto compare_charbags = [&dict_charbags, required_hash](const int a, const int b) {\n size_t a_hash, b_hash;\n\n // FIXME how to do this properly? This is really ugly.\n if (a == -1)\n a_hash = required_hash;\n else\n a_hash = dict_charbags[a].hash();\n if (b == -1)\n b_hash = required_hash;\n else\n b_hash = dict_charbags[b].hash();\n\n return a_hash < b_hash;\n };\n\n {\n auto it = std::lower_bound(possible_charbags.begin() + start_idx,\n possible_charbags.end(), -1, compare_charbags);\n\n for (auto ie = possible_charbags.end();\n it != ie && dict_charbags[*it].hash() == required_hash; ++it)\n if (charbag == dict_charbags[*it]) {\n words.emplace_back(*it);\n f(words);\n words.pop_back();\n // There's at most one hit, and we found one.\n return;\n }\n }\n}\n\ntemplate \nvoid forAllAnagrams_iter(const vector &dict_charbags,\n const vector &old_possible_charbags,\n const CharBag &charbag, Fn &&f,\n vector &words, size_t start_idx, int curr_len, int max_len) {\n if (curr_len+1 >= max_len) {\n forAllAnagrams_iter_last(dict_charbags, old_possible_charbags, charbag, f,\n words, start_idx);\n return;\n }\n vector possible_charbags;\n for (int i = start_idx, ie = old_possible_charbags.size(); i(f), words, i, curr_len+1, max_len);\n words.pop_back();\n }\n}\n\ntemplate \nvoid forAllAnagrams(const vector &dict_charbags, const CharBag &charbag,\n int max_len, Fn &&f) {\n vector words;\n vector possible_charbags(dict_charbags.size());\n std::iota(possible_charbags.begin(), possible_charbags.end(), 0);\n forAllAnagrams_iter(dict_charbags, possible_charbags,\n charbag, forward(f), words, 0, 0, max_len);\n}\n\n// The words vector contains vectors of anagram-equivalent words.\n// Output all possible combinations of them.\nstatic void outputWords(ostream &stream, const vector &word_idxs,\n const vector> &words) {\n int size = word_idxs.size();\n vector idxs(size);\n\n while (true) {\n stream << words[word_idxs[0]][idxs[0]];\n for (int i = 1; i= 0 && ++idxs[curr] == words[word_idxs[curr]].size()) {\n idxs[curr] = 0;\n curr--;\n }\n if (curr < 0)\n break;\n }\n}\n\nstatic void usage(char * const *argv, po::options_description &visible) {\n cout << \"Usage: \" << argv[0] << \" [options] sentence\" << endl;\n cout << visible << endl;\n exit(0);\n}\n\nstatic po::variables_map parse_args(int argc, char * const *argv) {\n bool help = false;\n\n po::options_description visible(\"Allowed options\"), cmdline_opt;\n visible.add_options()\n (\"help,h\", po::bool_switch(&help)->default_value(false), \"show this help\")\n (\"dict,d\", po::value()->default_value(\"words.txt\"),\n \"dictionary (word list) to use\")\n (\"len,l\", po::value()->default_value(3), \"maximum anagram length in words\")\n (\"remove,r\", po::value()->default_value(\"\"),\n \"remove characters from input (find anagrams containing given string)\");\n\n po::options_description hidden;\n hidden.add_options()\n (\"sentence\", po::value()->required(), \"sentence\");\n\n cmdline_opt.add(visible).add(hidden);\n\n po::positional_options_description p;\n p.add(\"sentence\", 1);\n\n po::variables_map vm;\n try {\n po::store(po::command_line_parser(argc, argv).options(cmdline_opt).positional(p).run(), vm);\n po::notify(vm);\n } catch (po::error &) {\n help = true;\n }\n\n if (help)\n usage(argv, visible);\n\n return vm;\n}\n\nCharMap generateCharMap(const UnicodeString &input) {\n CharMap charmap;\n\n unordered_map char_counts;\n\n forAllAlpha(input, [&char_counts](UChar c) {\n ++char_counts[c];\n return true;\n });\n\n if (char_counts.size() > MAX_LETTERS) {\n cerr << \"Error: More than \" << MAX_CHARIDX+1\n << \" different characters in input.\" << endl;\n exit(1);\n }\n\n vector> charmap_with_counts;\n for (const auto &it : char_counts)\n charmap_with_counts.emplace_back(-it.second, it.first);\n\n std::sort(charmap_with_counts.begin(), charmap_with_counts.end());\n\n int i = 0;\n for (const auto &p : charmap_with_counts)\n charmap[p.second] = i++;\n\n return charmap;\n}\n\nint main(int argc, char **argv) {\n std::locale::global(std::locale(\"\"));\n\n auto vm = parse_args(argc, argv);\n\n UnicodeString input = UnicodeString(vm[\"sentence\"].as().c_str()).toLower();\n UnicodeString remove = UnicodeString(vm[\"remove\"].as().c_str()).toLower();\n\n CharMap charmap;\n vector reverse_charmap;\n\n charmap = generateCharMap(input);\n\n auto input_charbag = CharBag::fromUString(input, charmap).value();\n auto remove_charbag_opt = CharBag::fromUString(remove, charmap);\n\n if (remove_charbag_opt == nullopt || !remove_charbag_opt.value().isSubsetOf(input_charbag)) {\n cerr << \"Error: characters for substring \\\"\" << remove\n << \"\\\" not found in string \\\"\" << input\n << \"\\\"!\" << endl;\n exit(2);\n }\n\n auto stripped_input_charbag = (input_charbag - remove_charbag_opt.value()).value();\n\n vector> dict_words;\n vector dict_charbags;\n tie(dict_words, dict_charbags) = loadDictionary(\n vm[\"dict\"].as(), stripped_input_charbag, charmap);\n\n forAllAnagrams(dict_charbags, stripped_input_charbag, vm[\"len\"].as(),\n [&dict_words](const vector &word_idxs) {\n assert(!word_idxs.empty());\n outputWords(cout, word_idxs, dict_words);\n });\n}\n", "meta": {"hexsha": "db39208d34b773f3a3083f99c022fad7b6a0a47c", "size": 16963, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ufag.cpp", "max_stars_repo_name": "sliedes/ufag", "max_stars_repo_head_hexsha": "055040477ac5d8419e35e8a66966287ddd4d527b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ufag.cpp", "max_issues_repo_name": "sliedes/ufag", "max_issues_repo_head_hexsha": "055040477ac5d8419e35e8a66966287ddd4d527b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-12-19T21:42:50.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-06T08:41:52.000Z", "max_forks_repo_path": "ufag.cpp", "max_forks_repo_name": "sliedes/ufag", "max_forks_repo_head_hexsha": "055040477ac5d8419e35e8a66966287ddd4d527b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2017-12-19T21:18:30.000Z", "max_forks_repo_forks_event_max_datetime": "2017-12-19T21:18:30.000Z", "avg_line_length": 31.945386064, "max_line_length": 100, "alphanum_fraction": 0.6039615634, "num_tokens": 4506, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660543, "lm_q2_score": 0.4571367168274948, "lm_q1q2_score": 0.29775822432305726}} {"text": "// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*-\n// Learn more about Rcpp at:\n//\n// http://www.rcpp.org/\n// http://adv-r.had.co.nz/Rcpp.html\n// http://gallery.rcpp.org/\n//\n\n// we only include RcppArmadillo.h which pulls Rcpp.h in for us\n#include \"RcppArmadillo.h\"\nusing namespace Rcpp;\n\n// via the depends attribute we tell Rcpp to create hooks for\n// RcppArmadillo so that the build process will know what to do\n//\n// [[Rcpp::depends(RcppArmadillo)]]\n// [[Rcpp::depends(BH)]]\n\n// one include file from Boost to access the digamma function\n#include \n\n\n/*----------------------------------------------------------------------------*/\n// SlalomModel class definition and module //\n\n//' SlalomModel C++ class\n//'\n//' @description\n//' A C++ class for SlalomModel models.\n//'\n//' @param Y_init matrix of expression values\n//' @param pi_init G x K matrix with each entry being the prior\n//' probability for a gene g being active for factor k.\n//' @param X_init matrix of initial factor states (N x K)\n//' @param W_init G x K matrix of initial weights\n//' @param prior_alpha numeric vector of length two giving prior values\n//' for the gamma hyperparameters of the precisions\n//' @param prior_epsilon numeric vector of length two giving prior values\n//' for the gamma hyperparameters of the residual variances\n//'\n//' @return\n//' an object of the SlalomModel class\n//'\n//' @useDynLib slalom, .registration=TRUE, .fixes=\"Rcpp_\"\n//' @importFrom Rcpp evalCpp\n//' @exportClass Rcpp_SlalomModel\n//' @name SlalomModel\n//' @aliases SlalomModel\nclass SlalomModel {\n // base class for slalom holding models\npublic:\n // declare necessary variables for alpha\n double alpha_pa;\n double alpha_pb;\n arma::vec alpha_a;\n arma::vec alpha_b;\n arma::vec alpha_E1;\n arma::vec alpha_lnE1;\n // declare necessary variables for epsilon\n double epsilon_pa;\n double epsilon_pb;\n arma::vec epsilon_a;\n arma::vec epsilon_b;\n arma::vec epsilon_E1;\n arma::vec epsilon_lnE1;\n arma::vec epsilon_diagSigmaS;\n // declare necessary variables for X\n arma::mat X_E1;\n arma::mat X_diagSigmaS;\n arma::mat X_init;\n // declare necessary variables for W\n arma::mat W_E1;\n arma::mat W_sigma2;\n arma::mat W_E2diag;\n arma::mat W_gamma0;\n arma::mat W_gamma1;\n // declare necessary variables for Z\n arma::mat Z_E1;\n // declare other variables\n arma::mat I;\n arma::mat Pi_a;\n arma::mat Pi_b;\n arma::mat Pi_pa;\n arma::mat Pi_E1;\n arma::mat Y;\n arma::mat pseudo_Y;\n arma::vec YY;\n arma::mat Known;\n int K;\n int N;\n int G;\n int nAnnotated;\n int nHidden;\n int nKnown;\n int nIterations;\n int minIterations;\n int iterationCount;\n double tolerance;\n bool forceIterations;\n bool shuffle;\n bool converged;\n double nScale;\n std::vector< std::string > noiseModel;\n double onF;\n arma::vec nOn;\n arma::vec iUnannotatedDense;\n arma::vec iUnannotatedSparse;\n arma::uvec doUpdate;\n arma::uvec pretrain_order;\n bool dropFactors;\n bool learnPi;\n // names\n Rcpp::StringVector termNames;\n Rcpp::StringVector cellNames;\n Rcpp::StringVector geneNames;\n // methods\n void train(void);\n void update(void);\n void updateEpsilon(void);\n void updateAlpha(const int);\n void updateX(const int);\n void updateW(const int);\n void updatePi(const int);\n // constructor\n SlalomModel() {}\n SlalomModel(arma::mat Y_init, arma::mat pi_init, arma::mat X_init,\n arma::mat W_init, arma::vec prior_alpha, arma::vec prior_epsilon) :\n Y(Y_init), Pi_E1(pi_init), I(pi_init), W_gamma0(pi_init), X_E1(X_init),\n W_E1(W_init) {\n K = pi_init.n_cols;\n N = Y_init.n_rows;\n G = Y_init.n_cols;\n nScale = 100.0;\n // initialise squared column sums\n YY = arma::zeros(G);\n for (int g=0; g < G; g++) {\n YY(g) = arma::accu(Y.col(g) % Y.col(g));\n }\n // initialise alpha variables\n alpha_pa = prior_alpha[0];\n alpha_pb = prior_alpha[1];\n alpha_a = arma::ones(K) * alpha_pa;\n alpha_b = arma::ones(K) * alpha_pb;\n alpha_E1 = alpha_b / alpha_a;\n alpha_lnE1 = arma::ones(K);\n for (int i = 0; i < K; i++) {\n alpha_lnE1(i) = boost::math::digamma(alpha_a(i));\n }\n alpha_lnE1 = alpha_lnE1 - arma::log(alpha_b);\n // initialise epsilon variables\n epsilon_pa = prior_epsilon[0];\n epsilon_pb = prior_epsilon[1];\n epsilon_a = arma::ones(G) * epsilon_pa;\n epsilon_b = arma::ones(G) * epsilon_pb;\n epsilon_E1 = epsilon_b / epsilon_a;\n epsilon_lnE1 = arma::ones(G);\n for (int i = 0; i < G; i++) {\n epsilon_lnE1(i) = boost::math::digamma(epsilon_a(i));\n }\n epsilon_lnE1 = epsilon_lnE1 - arma::log(epsilon_b);\n epsilon_diagSigmaS = arma::zeros(G);\n // initialise X variables\n X_diagSigmaS = arma::ones(N, K);\n // initialise W variables\n W_gamma1 = 1.0 - W_gamma0;\n W_sigma2 = arma::ones(G, K);\n W_E2diag = arma::zeros(G, K);\n // initialise iterations\n converged = false;\n iterationCount = 0;\n tolerance = 1e-08;\n learnPi = true;\n doUpdate = arma::ones(K);\n minIterations = 1;\n nIterations = 1;\n }\n};\n\n\n/*----------------------------------------------------------------------------*/\n// SlalomModel class train method\n\n// train method\nvoid SlalomModel::train(void) {\n /*\n Iterate updates of weights (with spike-and-slab prior), ARD parameters, factors, annd noise parameters.\n\n No arguments, but utilises the following parameters defined in the object:\n nIterations (int): Number of iterations.\n forceIterations (bool): Force the model to update `nIteration` times.\n tolerance (float): Tolerance to monitor convergence of reconstruction error\n minIterations (int): Minimum number of iterations the model should perform.\n */\n arma::umat Ion = (this->W_gamma0 > .5);\n arma::mat Zr = this->X_E1 * (this->W_E1.t() % Ion.t());\n arma::mat Zd = this->Z_E1 - Zr;\n arma::rowvec error(1);\n arma::rowvec error_old(1);\n error.fill(arma::mean(arma::mean((arma::abs(Zd)))));\n double meanerr = arma::mean(error);\n // mean absolute error\n error_old.fill(100);\n this->converged = false;\n // iterate model to train it\n this->iterationCount = 0;\n for (int iter = 0; iter <= this->nIterations; iter++) {\n // t = time.time();\n this->update();\n this->iterationCount++;\n if (iter % 100 == 0) {\n Rcout << \"iteration \" << iter << std::endl;\n }\n if (iter % 50 == 0) {\n error_old = error;\n Zr = this->X_E1 * this->W_E1.t();\n Zd = this->Z_E1 - Zr;\n error.fill(arma::mean(arma::mean((arma::abs(Zd)))));\n // mean absolute error\n this->converged = arma::approx_equal(error_old, error, \"absdiff\",\n this->tolerance);\n double meanerr = arma::mean(error);\n }\n if ( this->converged && !(this->forceIterations) &&\n (iter > this->minIterations) ) {\n Rcout << \"Model converged after \" << iter << \" iterations.\" << std::endl;\n break;\n }\n // this->Z_E1 = this->X_E1 * this->W_E1.t();\n }\n if (!converged) {\n Rcout << \"Model not converged after \" << this->nIterations << \" iterations.\" << std::endl;\n }\n}\n\n\n/*----------------------------------------------------------------------------*/\n// SlalomModel class update methods //\n\n// wrapper around R's RNG such that we get a uniform distribution over\n// [0,n) as required by the STL algorithm\ninline int randWrapper(const int n) { return floor(unif_rand() * n); }\n\nvoid SlalomModel::update(void) {\n /*\n Do one update of weights (with spike-and-slab prior), ARD parameters, factors, annd noise parameters.\n\n */\n this->epsilon_diagSigmaS = arma::zeros(this->K);\n // arma::umat Ion = (this->W_gamma0 > .5);\n // check above: set parameter to zero with every update?\n arma::uvec kRange;\n if (this->iterationCount == 1) {\n kRange = this->pretrain_order;\n } else {\n kRange = arma::regspace(0, (this->K - 1));\n }\n if (this->shuffle == true && this->iterationCount > 1) {\n arma::uvec kunfix = arma::regspace(this->nKnown,\n (this->K - 1));\n std::random_shuffle(kunfix.begin(), kunfix.end(), randWrapper);\n for (int i = 0; i < (this->K - this->nKnown); ++i) {\n int ii = i + this->nKnown;\n kRange(ii) = kunfix(i);\n }\n }\n // switch factors off such that they can't be turned back on\n // Regular iterator, non-C++11\n for (int m = 0; m < this->K; m++) {\n int k = kRange[m];\n if (this->doUpdate[k]) {\n if (this->dropFactors == false || this->iterationCount < 10 ||\n (this->alpha_E1[k] / arma::var(this->X_E1.col(k))) < 1e10) {\n this->updateW(k);\n if (this->learnPi) {\n if (arma::any((this->iUnannotatedSparse - 1) == k)) {\n this->updatePi(k);\n }\n }\n this->updateAlpha(k);\n this->updateX(k);\n } else {\n this->doUpdate[k] = 0;\n Rcout << \"Switched off factor \" << k << std::endl;\n }\n }\n }\n // const char noise_gauss = \"gauss\";\n // if (std::strcmp(this->noiseModel, noise_gauss) == 0) {\n // // this->updateEpsilon();\n // };\n this->updateEpsilon();\n}\n\n\nvoid SlalomModel::updateW(const int k) {\n // update the factor weights\n // define logPi values\n arma::vec logPi;\n int Muse = arma::accu(this->doUpdate);\n if (k < this->nKnown || arma::any((this->iUnannotatedSparse - 1) == k) ||\n arma::any((this->iUnannotatedDense - 1) == k)) {\n logPi = arma::log(this->Pi_E1.col(k) / (1.0 - this->Pi_E1.col(k)));\n // careful of divide-by-zero errors here\n } else if (this->nScale > 0 && this->nScale < this->N) {\n logPi = arma::log(this->Pi_E1.col(k) / (1.0 - this->Pi_E1.col(k)));\n // careful of divide-by-zero errors here\n arma::uvec isOFF_ = arma::find(this->Pi_E1.col(k) < 0.5);\n arma::uvec kvec(1);\n kvec(0) = k;\n logPi(isOFF_) = ((this->N / this->nScale) *\n arma::log(this->Pi_E1(isOFF_, kvec) /\n (1 - this->Pi_E1(isOFF_, kvec))));\n // careful of divide-by-zero errors here\n arma::uvec isON_ = arma::find(this->Pi_E1.col(k) > 0.5);\n if (this->onF > 1.0) {\n logPi(isON_) = this->onF * arma::log(\n this->Pi_E1(isON_, kvec) / (1 - this->Pi_E1(isON_, kvec)));\n }\n } else {\n logPi = arma::log(this->Pi_E1.col(k) / (1 - this->Pi_E1.col(k)));\n }\n arma::vec sigma2Sigmaw;\n sigma2Sigmaw = (1.0 / this->epsilon_E1) * this->alpha_E1(k);\n arma::uvec set1 = arma::regspace(0, 1, k - 1); // zero-indexing\n arma::uvec set2 = arma::regspace(k + 1, 1, this->K - 1);\n arma::uvec setMinus = arma::join_cols(set1, set2);\n arma::uvec idx = arma::find(this->doUpdate(setMinus) == 1);\n setMinus = setMinus(idx);\n\n arma::vec SmTSk = arma::sum(\n (arma::repmat(this->X_E1.col(k), 1, Muse - 1) %\n this->X_E1.cols(setMinus)), 0).t();\n double tmp = arma::as_scalar(this->X_E1.col(k).t() * this->X_E1.col(k));\n double SmTSm = (tmp + arma::sum(this->X_diagSigmaS.col(k)));\n\n arma::vec b;\n arma::vec diff;\n b = (this->W_gamma0.cols(setMinus) % this->W_E1.cols(setMinus)) * SmTSk;\n diff = (this->X_E1.col(k).t() * this->Z_E1).t() - b;\n arma::vec diff2 = diff % diff;\n arma::vec SmTSmSig = SmTSm + sigma2Sigmaw; // same as Py\n\n // update gamma and W\n arma::vec u_qm = (logPi + 0.5 * arma::log(sigma2Sigmaw) - 0.5 *\n arma::log(SmTSmSig) + (0.5 * this->epsilon_E1) %\n (diff2 / SmTSmSig));\n this->W_gamma0.col(k) = 1.0 / (1 + arma::exp(-u_qm));\n this->W_gamma1.col(k) = 1.0 - this->W_gamma0.col(k);\n this->W_E1.col(k) = (diff / SmTSmSig);\n this->W_sigma2.col(k) = (1.0 / this->epsilon_E1) / SmTSmSig;\n this->W_E2diag.col(k) = ((this->W_E1.col(k) % this->W_E1.col(k)) +\n this->W_sigma2.col(k));\n}\n\n\nvoid SlalomModel::updatePi(const int k) {\n // update Pi in a SlalomModel class object\n this->Pi_a.col(k) = this->Pi_pa.col(k) + arma::accu(this->W_gamma0.col(k));\n this->Pi_b.col(k) = (this->Pi_pa.col(k) + this->G -\n arma::accu(this->W_gamma0.col(k)));\n this->Pi_E1.col(k) = this->Pi_a.col(k) / this->Pi_a.col(k) +\n this->Pi_b.col(k);\n}\n\nvoid SlalomModel::updateAlpha(const int k) {\n // pdate alpha in a SlalomModel class object - precisions\n double Ewdwd = arma::accu(this->W_gamma0.col(k) % this->W_E2diag.col(k));\n // elementwise mult.\n this->alpha_a(k) = this->alpha_pa + 0.5 * Ewdwd;\n this->alpha_b(k) = this->alpha_pb + arma::accu(this->W_gamma0.col(k)) / 2.0;\n this->alpha_E1(k) = this->alpha_b(k) / this->alpha_a(k);\n}\n\n\nvoid SlalomModel::updateX(const int k) {\n // update the factor states\n arma::uvec set1 = arma::regspace(0, 1, k - 1);\n arma::uvec set2 = arma::regspace(k + 1, 1, this->K - 1);\n arma::uvec setMinus = arma::join_cols(set1, set2);\n arma::uvec idx = arma::find(this->doUpdate(setMinus) == 1);\n setMinus = setMinus(idx);\n\n arma::vec SW_sigma;\n arma::vec SW2_sigma;\n\n SW2_sigma = ((this->W_gamma0.col(k) % this->W_E2diag.col(k)) %\n this->epsilon_E1);\n double alphaSm = arma::sum(SW2_sigma);\n\n for (int i = 0; i < this->N; i++) {\n this->X_diagSigmaS(i, k) = 1.0 / (1.0 + alphaSm);\n }\n\n if (k >= this->nKnown) {\n SW_sigma = (this->W_gamma0.col(k) %\n this->W_E1.col(k)) % this->epsilon_E1; // Gx1 vec\n arma::mat b0 = (this->X_E1.cols(setMinus) *\n (this->W_gamma0.cols(setMinus) % this->W_E1.cols(setMinus)).t()); // NxG mat.\n arma::vec b = b0 * SW_sigma; // NxG x Gx1 -> Nx1 vec\n arma::vec barmuX = (this->Z_E1 * SW_sigma) - b;\n // update X\n this->X_E1.col(k) = barmuX / (1.0 + alphaSm);\n // keep diagSigmaS\n this->epsilon_diagSigmaS(k) = arma::accu(this->X_diagSigmaS.col(k));\n }\n}\n\n\nvoid SlalomModel::updateEpsilon(void) {\n // update Epsilon (vectorised) - noise parameters\n arma::uvec update_cols = arma::find(this->doUpdate == 1);\n arma::mat SW_sigma = (this->W_gamma0.cols(update_cols) %\n this->W_E1.cols(update_cols)); // elementwise mult.; GxK mat\n arma::mat SW2_sigma = (this->W_gamma0.cols(update_cols) %\n this->W_E2diag.cols(update_cols)); // elementwise mult.; GxK mat\n arma::mat muSTmuS = (this->X_E1.cols(update_cols).t() *\n this->X_E1.cols(update_cols)); // KxK matrix\n arma::mat newmat = this->Z_E1.t() * this->X_E1.cols(update_cols);\n arma::vec t1 = arma::sum(SW_sigma % newmat, 1); // K length vec\n arma::vec t2 = arma::sum(SW2_sigma % arma::repmat(muSTmuS.diag().t() +\n this->epsilon_diagSigmaS(update_cols).t(), this->G, 1), 1);\n // set diagonals to zeros in muSTmuS for next calculation\n muSTmuS.diag().zeros();\n arma::vec t3 = arma::sum((SW_sigma * muSTmuS) % SW_sigma, 1);\n this->epsilon_E1 = 1.0 / ((0.5 * (this->YY + (-2 * t1 + t2 + t3))) /\n (0.5 * this->N));\n this->epsilon_a.fill(0.5 * this->N + this->epsilon_pa);\n this->epsilon_b = this->epsilon_pb + 0.5 * (this->YY + (-2 * t1 + t2 + t3));\n for (int i = 0; i < this->epsilon_E1.n_elem; i++) {\n if (this->epsilon_E1(i) > 1e6) {\n this->epsilon_E1(i) = 1e6;\n }\n }\n}\n\n\n\n/*----------------------------------------------------------------------------*/\n// SlalomModel Rcpp module\n\n// Define a module to make the C++ class available to R\nRCPP_MODULE(SlalomModel) {\n using namespace Rcpp;\n\n class_(\"SlalomModel\")\n // expose the default constructor\n .constructor()\n .constructor()\n //\n // fields\n .field(\"K\", &SlalomModel::K)\n .field(\"N\", &SlalomModel::N)\n .field(\"G\", &SlalomModel::G)\n .field(\"nScale\", &SlalomModel::nScale)\n .field(\"nAnnotated\", &SlalomModel::nAnnotated)\n .field(\"nHidden\", &SlalomModel::nHidden)\n .field(\"nKnown\", &SlalomModel::nKnown)\n .field(\"nIterations\", &SlalomModel::nIterations)\n .field(\"minIterations\", &SlalomModel::minIterations)\n .field(\"iterationCount\", &SlalomModel::iterationCount)\n .field(\"forceIterations\", &SlalomModel::forceIterations)\n .field(\"tolerance\", &SlalomModel::tolerance)\n .field(\"shuffle\", &SlalomModel::shuffle)\n .field(\"converged\", &SlalomModel::converged)\n .field(\"noiseModel\", &SlalomModel::noiseModel)\n .field(\"onF\", &SlalomModel::onF)\n // alpha\n .field(\"alpha_pa\", &SlalomModel::alpha_pa)\n .field(\"alpha_pb\", &SlalomModel::alpha_pb)\n .field(\"alpha_a\", &SlalomModel::alpha_a)\n .field(\"alpha_b\", &SlalomModel::alpha_b)\n .field(\"alpha_E1\", &SlalomModel::alpha_E1)\n .field(\"alpha_lnE1\", &SlalomModel::alpha_lnE1)\n // epsilon\n .field(\"epsilon_pa\", &SlalomModel::epsilon_pa)\n .field(\"epsilon_pb\", &SlalomModel::epsilon_pb)\n .field(\"epsilon_a\", &SlalomModel::epsilon_a)\n .field(\"epsilon_b\", &SlalomModel::epsilon_b)\n .field(\"epsilon_E1\", &SlalomModel::epsilon_E1)\n .field(\"epsilon_lnE1\", &SlalomModel::epsilon_lnE1)\n .field(\"epsilon_diagSigmaS\", &SlalomModel::epsilon_diagSigmaS)\n // X\n .field(\"X_E1\", &SlalomModel::X_E1)\n .field(\"X_diagSigmaS\", &SlalomModel::X_diagSigmaS)\n .field(\"X_init\", &SlalomModel::X_init)\n // W\n .field(\"W_E1\", &SlalomModel::W_E1)\n .field(\"W_sigma2\", &SlalomModel::W_sigma2)\n .field(\"W_E2diag\", &SlalomModel::W_E2diag)\n .field(\"W_gamma0\", &SlalomModel::W_gamma0)\n .field(\"W_gamma1\", &SlalomModel::W_gamma1)\n // Z\n .field(\"Z_E1\", &SlalomModel::Z_E1)\n // Pi\n .field(\"Pi_a\", &SlalomModel::Pi_a)\n .field(\"Pi_pa\", &SlalomModel::Pi_pa)\n .field(\"Pi_b\", &SlalomModel::Pi_b)\n .field(\"Pi_E1\", &SlalomModel::Pi_E1)\n .field(\"I\", &SlalomModel::I)\n // other variables\n .field(\"Known\", &SlalomModel::Known)\n .field(\"Y\", &SlalomModel::Y)\n .field(\"pseudo_Y\", &SlalomModel::pseudo_Y)\n .field(\"YY\", &SlalomModel::YY)\n .field(\"iUnannotatedDense\", &SlalomModel::iUnannotatedDense)\n .field(\"iUnannotatedSparse\", &SlalomModel::iUnannotatedSparse)\n .field(\"nOn\", &SlalomModel::nOn)\n .field(\"doUpdate\", &SlalomModel::doUpdate)\n .field(\"pretrain_order\", &SlalomModel::pretrain_order)\n .field(\"learnPi\", &SlalomModel::learnPi)\n .field(\"dropFactors\", &SlalomModel::dropFactors)\n // names\n .field(\"termNames\", &SlalomModel::termNames)\n .field(\"cellNames\", &SlalomModel::cellNames)\n .field(\"geneNames\", &SlalomModel::geneNames)\n // methods\n .method(\"train\", &SlalomModel::train , \"Train the SlalomModel\")\n .method(\"update\", &SlalomModel::update , \"Update the SlalomModel\")\n .method(\"updateW\", &SlalomModel::updateW , \"Update W\")\n .method(\"updateX\", &SlalomModel::updateX , \"Update X\")\n .method(\"updatePi\", &SlalomModel::updatePi , \"Update Pi\")\n .method(\"updateEpsilon\", &SlalomModel::updateEpsilon , \"Update Epsilon\")\n .method(\"updateAlpha\", &SlalomModel::updateAlpha , \"Update alpha\")\n ;\n}\n", "meta": {"hexsha": "2888e174e1542ffc8a2f2914597f4a482b5be968", "size": 20064, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "R_package/src/slalom-classes.cpp", "max_stars_repo_name": "dburkhardt/slalom", "max_stars_repo_head_hexsha": "547a56316e5c3ccc63e592eb907dc53b00212466", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 24.0, "max_stars_repo_stars_event_min_datetime": "2017-10-30T13:58:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-14T17:07:46.000Z", "max_issues_repo_path": "R_package/src/slalom-classes.cpp", "max_issues_repo_name": "dburkhardt/slalom", "max_issues_repo_head_hexsha": "547a56316e5c3ccc63e592eb907dc53b00212466", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2017-11-11T04:49:01.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-24T13:24:50.000Z", "max_forks_repo_path": "R_package/src/slalom-classes.cpp", "max_forks_repo_name": "dburkhardt/slalom", "max_forks_repo_head_hexsha": "547a56316e5c3ccc63e592eb907dc53b00212466", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2018-01-09T12:19:31.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-26T17:01:57.000Z", "avg_line_length": 38.0721062619, "max_line_length": 108, "alphanum_fraction": 0.5750099681, "num_tokens": 5926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548646660542, "lm_q2_score": 0.4571367168274948, "lm_q1q2_score": 0.2977582243230572}} {"text": "#ifndef TCM_BLAS_WRAPPER_HPP\n#define TCM_BLAS_WRAPPER_HPP\n\n#include \n#include \n#include \n\n#include \n\n#include \n#include \n#include \n\n\n///////////////////////////////////////////////////////////////////////////////\n/// \\file blas_wrapper.hpp\n/// \\brief Defines template versions of some BLAS routines.\n///////////////////////////////////////////////////////////////////////////////\n\n\n\n#define REGISTER_BLAS(general_f, s_f, d_f, c_f, z_f) \\\n\tnamespace { \\\n\t\ttemplate \\\n __attribute__((always_inline)) \\\n\t\tinline \\\n\t\tauto general_f##_impl( utils::Type2Type \\\n\t\t , Args&&... args) noexcept \\\n\t\t{ return s_f(std::forward(args)...); } \\\n\t\t \\\n\t\ttemplate \\\n __attribute__((always_inline)) \\\n\t\tinline \\\n\t\tauto general_f##_impl( utils::Type2Type \\\n\t\t , Args&&... args) noexcept \\\n\t\t{ return d_f(std::forward(args)...); } \\\n\t\t \\\n\t\ttemplate \\\n __attribute__((always_inline)) \\\n\t\tinline \\\n\t\tauto general_f##_impl( utils::Type2Type> \\\n\t\t , Args&&... args) noexcept \\\n\t\t{ return c_f(std::forward(args)...); } \\\n\t\t \\\n\t\ttemplate \\\n __attribute__((always_inline)) \\\n\t\tinline \\\n\t\tauto general_f##_impl( utils::Type2Type> \\\n\t\t , Args&&... args) noexcept \\\n\t\t{ return z_f(std::forward(args)...); } \\\n\t} \\\n \\\n\ttemplate \\\n\t__attribute__((always_inline)) \\\n\tinline \\\n\tauto general_f(Args&&... args) noexcept \\\n\t{ return general_f##_impl( utils::Type2Type{} \\\n\t , std::forward(args)...); \\\n\t} \n\n\n\n\n\n\n\nnamespace tcm {\n\nnamespace import {\n\n\nenum class Operator : char {None = 'N', T = 'T', H = 'C'};\n\n\n\n#ifdef USING_INTEL_MKL\n\tusing blas_int = long long int;\n#else\n#\tifdef USING_ATLAS\n\t\tusing blas_int = int;\n#\telse\n#\t\terror \"Need BLAS\"\n#\tendif\n#endif\n\n\n\n// ============================================================================\n// DOT PRODUCT \n// ============================================================================\n\n\nextern \"C\" {\n\nfloat sdot_\n( blas_int const* N\n, float const* X, blas_int const* INCX\n, float const* Y, blas_int const* INCY );\n\ndouble ddot_\n( blas_int const* N\n, double const* X, blas_int const* INCX\n, double const* Y, blas_int const* INCY );\n\nstd::complex cdotc_\n( blas_int const* N\n, std::complex const* X, blas_int const* INCX\n, std::complex const* Y, blas_int const* INCY );\n\nstd::complex zdotc_\n( blas_int const* N\n, std::complex const* X, blas_int const* inc_X\n, std::complex const* Y, blas_int const* inc_Y );\n\n} // extern \"C\"\n\nREGISTER_BLAS(dotc, sdot_, ddot_, cdotc_, zdotc_)\n\n\ntemplate< class _T\n , class = std::enable_if_t\n < std::is_same<_T, float>() \n or std::is_same<_T, double>()\n or std::is_same<_T, std::complex>()\n or std::is_same<_T, std::complex>()\n >\n >\ninline\nauto dot( std::size_t const n\n , _T const* X, blas_int const INCX\n , _T const* Y, blas_int const INCY\n ) -> _T\n{\n\tif(n == 0) return _T{0.0};\n\n\tassert(X != nullptr and INCX != 0);\n\tassert(Y != nullptr and INCY != 0);\n\t/*\n\tutils::assert_valid( const_blas_iterator<_T>{X , INCX}\n\t , const_blas_iterator<_T>{X + n * INCX, INCX} );\n\tutils::assert_valid( const_blas_iterator<_T>{Y , INCY}\n\t , const_blas_iterator<_T>{Y + n * INCY, INCY} );\n\t*/\n\n\tauto const N = boost::numeric_cast(n);\t\n\tauto const result = dotc<_T>(&N, X, &INCX, Y, &INCY);\n\n\tutils::assert_valid(result);\n\treturn result;\n}\n\n\n\n// ============================================================================\n// AXPY \n// ============================================================================\n\nextern \"C\" {\n\nvoid saxpy_\n( blas_int const* N, float const* A\n, float const* X, blas_int const* INCX\n, float * Y, blas_int const* INCY );\n\nvoid daxpy_\n( blas_int const* N, double const* A\n, double const* X, blas_int const* INCX\n, double * Y, blas_int const* INCY );\n\nvoid caxpy_\n( blas_int const* N, std::complex const* A\n, std::complex const* X, blas_int const* INCX\n, std::complex * Y, blas_int const* INCY );\n\nvoid zaxpy_\n( blas_int const* N, std::complex const* A\n, std::complex const* X, blas_int const* INCX\n, std::complex * Y, blas_int const* INCY );\n\n} // extern \"C\"\n\nREGISTER_BLAS(axpy, saxpy_, daxpy_, caxpy_, zaxpy_)\n\ntemplate< class _T\n , class = std::enable_if_t\n < std::is_same<_T, float>() \n or std::is_same<_T, double>()\n or std::is_same<_T, std::complex>()\n or std::is_same<_T, std::complex>()\n >\n >\ninline\nauto axpy( std::size_t const n, _T const a\n , _T const* X, blas_int const INCX\n , _T * Y, blas_int const INCY ) -> void\n{\n\tif(n == 0) return;\n\n\tassert(X != nullptr and INCX != 0);\n\tassert(Y != nullptr and INCY != 0);\n\t/*\n\tassert_valid( const_blas_iterator<_T>{X , INCX}\n\t , const_blas_iterator<_T>{X + n * INCX, INCX} );\n\tassert_valid( const_blas_iterator<_T>{Y , INCY}\n\t , const_blas_iterator<_T>{Y + n * INCY, INCY} );\n\t*/\n\tauto const N = boost::numeric_cast(n);\t\n\t\n\taxpy<_T>(&N, &a, X, &INCX, Y, &INCY);\n\n\t/*\n\tassert_valid( const_blas_iterator<_T>{Y , INCY}\n\t , const_blas_iterator<_T>{Y + n * INCY, INCY} );\n\t*/\n}\n\n\n\n\n\n\n// ============================================================================\n// MATRIX-VECTOR MULTIPLICATION \n// ============================================================================\n\nextern \"C\" {\n\nvoid sgemv_\n( char const* TRANSA\n, blas_int const* M, blas_int const* N\n, float const* ALPHA, float const* A, blas_int const* LDA\n, float const* X, blas_int const* INCX\n, float const* BETA, float* Y, blas_int const* INCY );\n\nvoid dgemv_\n( char const* TRANSA\n, blas_int const* M, blas_int const* N\n, double const* ALPHA, double const* A, blas_int const* LDA\n, double const* X, blas_int const* INCX\n, double const* BETA, double* Y, blas_int const* INCY );\n\nvoid cgemv_\n( char const* TRANSA\n, blas_int const* M, blas_int const* N\n, std::complex const* ALPHA\n, std::complex const* A, blas_int const* LDA\n, std::complex const* X, blas_int const* INCX\n, std::complex const* BETA\n, std::complex* Y, blas_int const* INCY );\n\nvoid zgemv_\n( char const* TRANSA\n, blas_int const* M, blas_int const* N\n, std::complex const* ALPHA\n, std::complex const* A, blas_int const* LDA\n, std::complex const* X, blas_int const* INCX\n, std::complex const* BETA\n, std::complex* Y, blas_int const* INCY );\n\n} // extern \"C\"\n\nREGISTER_BLAS(gemv, sgemv_, dgemv_, cgemv_, zgemv_)\n\n\ntemplate< class _T\n , class = std::enable_if_t\n < std::is_same<_T, float>() \n or std::is_same<_T, double>()\n or std::is_same<_T, std::complex>()\n or std::is_same<_T, std::complex>()\n >\n >\nauto gemv( Operator const op_A\n , std::size_t const m, std::size_t const n\n , _T const ALPHA, _T const* A, blas_int const LDA\n , _T const* X, blas_int const INCX\n , _T const BETA, _T* Y, blas_int const INCY ) -> void\n{\n\tif(n == 0 or m == 0) return;\n\n\tassert(A != nullptr and LDA != 0);\n\tassert(X != nullptr and INCX != 0);\n\tassert(Y != nullptr and INCY != 0);\n\t/*\n\tutils::assert_valid(A, A + LDA * n);\n\tutils::assert_valid\n\t\t( const_blas_iterator<_T>{X, INCX}\n\t\t, const_blas_iterator<_T>{ X + (op_A == Operator::None ? n : m) * INCX\n\t\t , INCX }\n\t\t);\n\tutils::assert_valid\n\t\t( const_blas_iterator<_T>{Y, INCY}\n\t\t, const_blas_iterator<_T>{ Y + (op_A == Operator::None ? m : n) * INCY\n\t\t , INCY }\n\t\t);\n\t*/\n\n\tauto const TRANS = static_cast(op_A);\n\tauto const M = boost::numeric_cast(m);\n\tauto const N = boost::numeric_cast(n);\n\n\tassert(LDA >= M);\n\n\tgemv<_T>( &TRANS, &M, &N\n\t , &ALPHA, A, &LDA, X, &INCX\n\t , &BETA, Y, &INCY );\n\n\t/*\n\tutils::assert_valid\n\t\t( const_blas_iterator<_T>{Y, INCY}\n\t\t, const_blas_iterator<_T>{ Y + (op_A == Operator::None ? m : n) * INCY\n\t\t , INCY }\n\t\t);\n\t*/\n}\n\n\n\n\n// ============================================================================\n// MATRIX-MATRIX MULTIPLICATION \n// ============================================================================\n\nextern \"C\" {\n\nvoid sgemm_\n( char const* TRANSA, char const* TRANSB\n, blas_int const* M, blas_int const* N, blas_int const* K\n, float const* ALPHA\n, float const* A, blas_int const* LDA\n, float const* B, blas_int const* LDB\n, float const* BETA\n, float* C, blas_int const* LDC );\n\nvoid dgemm_\n( char const* TRANSA, char const* TRANSB\n, blas_int const* M, blas_int const* N, blas_int const* K\n, double const* ALPHA\n, double const* A, blas_int const* LDA\n, double const* B, blas_int const* LDB\n, double const* BETA\n, double* C, blas_int const* LDC );\n\nvoid cgemm_\n( char const* TRANSA, char const* TRANSB\n, blas_int const* M, blas_int const* N, blas_int const* K\n, std::complex const* ALPHA\n, std::complex const* A, blas_int const* LDA\n, std::complex const* B, blas_int const* LDB\n, std::complex const* BETA\n, std::complex* C, blas_int const* LDC );\n\nvoid zgemm_\n( char const* TRANSA, char const* TRANSB\n, blas_int const* M, blas_int const* N, blas_int const* K\n, std::complex const* ALPHA\n, std::complex const* A, blas_int const* LDA\n, std::complex const* B, blas_int const* LDB\n, std::complex const* BETA\n, std::complex* C, blas_int const* LDC );\n\n} // extern \"C\"\n\nREGISTER_BLAS(gemm, sgemm_, dgemm_, cgemm_, zgemm_)\n\ntemplate< class _T\n , class = std::enable_if_t\n < std::is_same<_T, float>() \n or std::is_same<_T, double>()\n or std::is_same<_T, std::complex>()\n or std::is_same<_T, std::complex>()\n >\n >\ninline\nauto gemm( Operator const op_A, Operator const op_B\n , std::size_t const m, std::size_t const n, std::size_t const k\n , _T const ALPHA, _T const* A, blas_int const LDA\n , _T const* B, blas_int const LDB\n , _T const BETA, _T* C, blas_int const LDC ) -> void\n{\n\tif(m == 0 or n == 0 or k == 0) return;\n\n\tassert(A != nullptr and LDA != 0);\n\tassert(B != nullptr and LDB != 0);\n\tassert(C != nullptr and LDC != 0);\n\t/*\n\tutils::assert_valid(A, A + LDA * (op_A == Operator::None ? k : m));\n\tutils::assert_valid(B, B + LDB * (op_B == Operator::None ? n : k));\n\tutils::assert_valid(C, C + LDC * n);\n\t*/\n\n\tauto const M = boost::numeric_cast(m);\n\tauto const N = boost::numeric_cast(n);\n\tauto const K = boost::numeric_cast(k);\n\tauto const TRANSA = static_cast(op_A);\n\tauto const TRANSB = static_cast(op_B);\n\n\tassert( LDA >= (op_A == Operator::None ? M : K) );\n\tassert( LDB >= (op_B == Operator::None ? K : N) );\n\tassert( LDC >= M );\n\n\tgemm<_T>( &TRANSA, &TRANSB, &M, &N, &K\n\t , &ALPHA, A, &LDA, B, &LDB\n\t , &BETA, C, &LDC );\n\n\t/*\n\tutils::assert_valid(C, C + LDC * n);\n\t*/\n}\n\n\n\n} // namespace import\n\n} // namespace tcm\n\n\n\n\n\n\n\n\n#endif // TCM_BLAS_WRAPPER_HPP\n", "meta": {"hexsha": "b5a4498f197ee6ba48e92b80bb4124afb07f88a7", "size": 13454, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/detail/blas_wrapper.hpp", "max_stars_repo_name": "twesterhout/plasmon-cpp", "max_stars_repo_head_hexsha": "a0e343ee718d9b30602b322ade6077e42e08d8e5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-05T11:12:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T11:12:07.000Z", "max_issues_repo_path": "include/detail/blas_wrapper.hpp", "max_issues_repo_name": "twesterhout/plasmon-cpp", "max_issues_repo_head_hexsha": "a0e343ee718d9b30602b322ade6077e42e08d8e5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/detail/blas_wrapper.hpp", "max_forks_repo_name": "twesterhout/plasmon-cpp", "max_forks_repo_head_hexsha": "a0e343ee718d9b30602b322ade6077e42e08d8e5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.6564705882, "max_line_length": 80, "alphanum_fraction": 0.487661662, "num_tokens": 3389, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6513548511303338, "lm_q2_score": 0.4571367168274948, "lm_q1q2_score": 0.2977582181353824}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Boost\n#include \n#include \n\n// Eigen\n#include \n#include \n\n// HDF5\n#include \n\n// OpenMP\n#include \n\n// Point-triangle distance and ray-triangle intersection.\n#include \"triangle_point/poitri.h\"\n#include \"triangle_ray/raytri.h\"\n#include \"box_triangle/aabb_triangle_overlap.h\"\n\n/** \\brief Compute triangle point distance and corresponding closest point.\n * \\param[in] point point\n * \\param[in] v1 first vertex\n * \\param[in] v2 second vertex\n * \\param[in] v3 third vertex\n * \\param[out] ray corresponding closest point\n * \\return distance\n */\nfloat triangle_point_distance(const Eigen::Vector3f &point, const Eigen::Vector3f &v1, const Eigen::Vector3f &v2, const Eigen::Vector3f &v3,\n Eigen::Vector3f &closest_point) {\n\n Vec3f x0(point.data());\n Vec3f x1(v1.data());\n Vec3f x2(v2.data());\n Vec3f x3(v3.data());\n\n Vec3f r(0);\n float distance = point_triangle_distance(x0, x1, x2, x3, r);\n\n for (int d = 0; d < 3; d++) {\n closest_point(d) = r[d];\n }\n\n return distance;\n}\n\n/** \\brief Test triangle ray intersection.\n * \\param[in] origin origin of ray\n * \\param[in] dest destination of ray\n * \\param[in] v1 first vertex\n * \\param[in] v2 second vertex\n * \\param[in] v3 third vertex\n * \\return intersects\n */\nbool triangle_ray_intersection(const Eigen::Vector3f &origin, const Eigen::Vector3f &dest,\n const Eigen::Vector3f &v1, const Eigen::Vector3f &v2, const Eigen::Vector3f &v3, float &t) {\n\n double _origin[3] = {origin(0), origin(1), origin(2)};\n double _dir[3] = {dest(0) - origin(0), dest(1) - origin(1), dest(2) - origin(2)};\n double _v1[3] = {v1(0), v1(1), v1(2)};\n double _v2[3] = {v2(0), v2(1), v2(2)};\n double _v3[3] = {v3(0), v3(1), v3(2)};\n\n // t is the distance, u and v are barycentric coordinates\n // http://fileadmin.cs.lth.se/cs/personal/tomas_akenine-moller/code/raytri_tam.pdf\n double _t, u, v;\n int success = intersect_triangle(_origin, _dir, _v1, _v2, _v3, &_t, &u, &v);\n t = _t;\n\n if (success) {\n return true;\n }\n\n return false;\n}\n\n/** \\brief Compute triangle box intersection.\n * \\param[in] min defining voxel\n * \\param[in] max defining voxel\n * \\param[in] v1 first vertex\n * \\param[in] v2 second vertex\n * \\param[in] v3 third vertex\n * \\return intersects\n */\nbool triangle_box_intersection(const Eigen::Vector3f &min, Eigen::Vector3f &max, const Eigen::Vector3f &v1, const Eigen::Vector3f &v2, const Eigen::Vector3f &v3) {\n float half_size[3] = {\n (max(0) - min(0))/2.,\n (max(1) - min(1))/2.,\n (max(2) - min(2))/2.\n };\n\n float center[3] = {\n max(0) - half_size[0],\n max(1) - half_size[1],\n max(2) - half_size[2]\n };\n\n float vertices[3][3] = {{v1(0), v1(1), v1(2)}, {v2(0), v2(1), v2(2)}, {v3(0), v3(1), v3(2)}};\n return triBoxOverlap(center, half_size, vertices);\n}\n\n/** \\brief Specifies the voxelization mode, i.e. which point of a voxel to use for SDF computation. */\nenum VoxelizationMode {\n CENTER = 0,\n CORNER = 1\n};\n\n/** \\brief Just encapsulating vertices and faces. */\nclass Mesh {\npublic:\n /** \\brief Empty constructor. */\n Mesh() {\n\n }\n\n /** \\brief Reading an off file and returning the vertices x, y, z coordinates and the\n * face indices.\n * \\param[in] filepath path to the OFF file\n * \\param[out] mesh read mesh with vertices and faces\n * \\return success\n */\n static bool from_off(const std::string filepath, Mesh& mesh) {\n\n std::ifstream* file = new std::ifstream(filepath.c_str());\n std::string line;\n std::stringstream ss;\n int line_nb = 0;\n\n std::getline(*file, line);\n ++line_nb;\n\n if (line != \"off\" && line != \"OFF\") {\n std::cout << \"[Error] Invalid header: \\\"\" << line << \"\\\", \" << filepath << std::endl;\n return false;\n }\n\n size_t n_edges;\n std::getline(*file, line);\n ++line_nb;\n\n int n_vertices;\n int n_faces;\n ss << line;\n ss >> n_vertices;\n ss >> n_faces;\n ss >> n_edges;\n\n for (size_t v = 0; v < n_vertices; ++v) {\n std::getline(*file, line);\n ++line_nb;\n\n ss.clear();\n ss.str(\"\");\n\n Eigen::Vector3f vertex;\n ss << line;\n ss >> vertex(0);\n ss >> vertex(1);\n ss >> vertex(2);\n\n mesh.add_vertex(vertex);\n }\n\n size_t n;\n for (size_t f = 0; f < n_faces; ++f) {\n std::getline(*file, line);\n ++line_nb;\n\n ss.clear();\n ss.str(\"\");\n\n size_t n;\n ss << line;\n ss >> n;\n\n if(n != 3) {\n std::cout << \"[Error] Not a triangle (\" << n << \" points) at \" << (line_nb - 1) << std::endl;\n return false;\n }\n\n Eigen::Vector3i face;\n ss >> face(0);\n ss >> face(1);\n ss >> face(2);\n\n mesh.add_face(face);\n }\n\n if (n_vertices != mesh.num_vertices()) {\n std::cout << \"[Error] Number of vertices in header differs from actual number of vertices.\" << std::endl;\n return false;\n }\n\n if (n_faces != mesh.num_faces()) {\n std::cout << \"[Error] Number of faces in header differs from actual number of faces.\" << std::endl;\n return false;\n }\n\n file->close();\n delete file;\n\n return true;\n }\n\n /** \\brief Write mesh to OFF file.\n * \\param[in] filepath path to OFF file to write\n * \\return success\n */\n bool to_off(const std::string filepath) {\n std::ofstream* out = new std::ofstream(filepath, std::ofstream::out);\n if (!static_cast(out)) {\n return false;\n }\n\n (*out) << \"OFF\" << std::endl;\n (*out) << this->num_vertices() << \" \" << this->num_faces() << \" 0\" << std::endl;\n\n for (unsigned int v = 0; v < this->num_vertices(); v++) {\n (*out) << this->vertices[v](0) << \" \" << this->vertices[v](1) << \" \" << this->vertices[v](2) << std::endl;\n }\n\n for (unsigned int f = 0; f < this->num_faces(); f++) {\n (*out) << \"3 \" << this->faces[f](0) << \" \" << this->faces[f](1) << \" \" << this->faces[f](2) << std::endl;\n }\n\n out->close();\n delete out;\n\n return true;\n }\n\n /** \\brief Add a vertex.\n * \\param[in] vertex vertex to add\n */\n void add_vertex(Eigen::Vector3f& vertex) {\n this->vertices.push_back(vertex);\n }\n\n /** \\brief Get the number of vertices.\n * \\return number of vertices\n */\n int num_vertices() {\n return static_cast(this->vertices.size());\n }\n\n /** \\brief Add a face.\n * \\param[in] face face to add\n */\n void add_face(Eigen::Vector3i& face) {\n this->faces.push_back(face);\n }\n\n /** \\brief Get the number of faces.\n * \\return number of faces\n */\n int num_faces() {\n return static_cast(this->faces.size());\n }\n\n /** \\brief Translate the mesh.\n * \\param[in] translation translation vector\n */\n void translate(const Eigen::Vector3f& translation) {\n for (int v = 0; v < this->num_vertices(); ++v) {\n for (int i = 0; i < 3; ++i) {\n this->vertices[v](i) += translation(i);\n }\n }\n }\n\n /** \\brief Scale the mesh.\n * \\param[in] scale scale vector\n */\n void scale(const Eigen::Vector3f& scale) {\n for (int v = 0; v < this->num_vertices(); ++v) {\n for (int i = 0; i < 3; ++i) {\n this->vertices[v](i) *= scale(i);\n }\n }\n }\n\n /** \\brief Voxelize the given mesh into a SDF.\n * \\param[out] sdf volume to fill with sdf values\n */\n void voxelize_sdf(Eigen::Tensor& sdf, const VoxelizationMode &mode) {\n\n int height = sdf.dimension(0);\n int width = sdf.dimension(1);\n int depth = sdf.dimension(2);\n\n #pragma omp parallel\n {\n #pragma omp for\n for (int i = 0; i < height*width*depth; i++) {\n int d = i%depth;\n int w = (i/depth)%width;\n int h = (i/depth)/width;\n\n sdf(h, w, d) = FLT_MAX;\n\n // the box corresponding to this voxel\n Eigen::Vector3f min(w, h, d);\n Eigen::Vector3f max(w + 1, h + 1, d + 1);\n\n Eigen::Vector3f center(w + 0.5f, h + 0.5f, d + 0.5f);\n if (mode == VoxelizationMode::CORNER) {\n center = Eigen::Vector3f(w, h, d);\n }\n\n // count number of intersections.\n int num_intersect = 0;\n for (unsigned int f = 0; f < this->num_faces(); ++f) {\n\n Eigen::Vector3f v1 = this->vertices[this->faces[f](0)];\n Eigen::Vector3f v2 = this->vertices[this->faces[f](1)];\n Eigen::Vector3f v3 = this->vertices[this->faces[f](2)];\n\n Eigen::Vector3f closest_point;\n triangle_point_distance(center, v1, v2, v3, closest_point);\n float distance = (center - closest_point).norm();\n\n if (distance < sdf(h, w, d)) {\n sdf(h, w, d) = distance;\n }\n\n bool intersect = triangle_ray_intersection(center, Eigen::Vector3f(0, 0, 0), v1, v2, v3, distance);\n\n if (intersect && distance >= 0) {\n num_intersect++;\n }\n }\n\n if (num_intersect%2 == 1) {\n sdf(h, w, d) *= -1;\n }\n }\n }\n }\n\n /** \\brief Voxelize the given mesh into an occupancy grid.\n * \\param[out] occ volume to fill\n */\n void voxelize_occ(Eigen::Tensor& occ, const VoxelizationMode &mode) {\n\n int height = occ.dimension(0);\n int width = occ.dimension(1);\n int depth = occ.dimension(2);\n\n #pragma omp parallel\n {\n #pragma omp for\n for (int i = 0; i < height*width*depth; i++) {\n int d = i%depth;\n int w = (i/depth)%width;\n int h = (i/depth)/width;\n\n Eigen::Vector3f min(w, h, d);\n Eigen::Vector3f max(w + 1, h + 1, d + 1);\n\n for (unsigned int f = 0; f < this->num_faces(); ++f) {\n\n Eigen::Vector3f v1 = this->vertices[this->faces[f](0)];\n Eigen::Vector3f v2 = this->vertices[this->faces[f](1)];\n Eigen::Vector3f v3 = this->vertices[this->faces[f](2)];\n\n bool overlap = triangle_box_intersection(min, max, v1, v2, v3);\n if (overlap) {\n occ(h, w, d) = 1;\n break;\n }\n }\n }\n }\n }\n\nprivate:\n\n /** \\brief Vertices as (x,y,z)-vectors. */\n std::vector vertices;\n\n /** \\brief Faces as list of vertex indices. */\n std::vector faces;\n};\n\n/** \\brief Write the given set of volumes to h5 file.\n * \\param[in] filepath h5 file to write\n * \\param[in] n number of volumes\n * \\param[in] height height of volumes\n * \\param[in] width width of volumes\n * \\param[in] depth depth of volumes\n * \\param[in] dense volume data\n */\ntemplate\nbool write_float_hdf5(const std::string filepath, Eigen::Tensor& tensor) {\n\n try {\n\n /*\n * Turn off the auto-printing when failure occurs so that we can\n * handle the errors appropriately\n */\n H5::Exception::dontPrint();\n\n /*\n * Create a new file using H5F_ACC_TRUNC access,\n * default file creation properties, and default file\n * access properties.\n */\n H5::H5File file(filepath, H5F_ACC_TRUNC);\n\n /*\n * Define the size of the array and create the data space for fixed\n * size dataset.\n */\n hsize_t rank = RANK;\n hsize_t dimsf[rank];\n for (int i = 0; i < rank; i++) {\n dimsf[i] = tensor.dimension(i);\n\n }\n H5::DataSpace dataspace(rank, dimsf);\n\n /*\n * Define datatype for the data in the file.\n * We will store little endian INT numbers.\n */\n H5::IntType datatype(H5::PredType::NATIVE_FLOAT);\n datatype.setOrder(H5T_ORDER_LE);\n\n /*\n * Create a new dataset within the file using defined dataspace and\n * datatype and default dataset creation properties.\n */\n H5::DataSet dataset = file.createDataSet(\"tensor\", datatype, dataspace);\n\n /*\n * Write the data to the dataset using default memory space, file\n * space, and transfer properties.\n */\n float* data = static_cast(tensor.data());\n dataset.write(data, H5::PredType::NATIVE_FLOAT);\n } // end of try block\n\n // catch failure caused by the H5File operations\n catch(H5::FileIException error) {\n error.printError();\n return false;\n }\n\n // catch failure caused by the DataSet operations\n catch(H5::DataSetIException error) {\n error.printError();\n return false;\n }\n\n // catch failure caused by the DataSpace operations\n catch(H5::DataSpaceIException error) {\n error.printError();\n return false;\n }\n\n // catch failure caused by the DataSpace operations\n catch(H5::DataTypeIException error) {\n error.printError();\n return false;\n }\n\n return true;\n}\n\n/** \\brief Write the given set of volumes to h5 file.\n * \\param[in] filepath h5 file to write\n * \\param[in] n number of volumes\n * \\param[in] height height of volumes\n * \\param[in] width width of volumes\n * \\param[in] depth depth of volumes\n * \\param[in] dense volume data\n */\ntemplate\nbool write_int_hdf5(const std::string filepath, Eigen::Tensor& tensor) {\n\n try {\n\n /*\n * Turn off the auto-printing when failure occurs so that we can\n * handle the errors appropriately\n */\n H5::Exception::dontPrint();\n\n /*\n * Create a new file using H5F_ACC_TRUNC access,\n * default file creation properties, and default file\n * access properties.\n */\n H5::H5File file(filepath, H5F_ACC_TRUNC);\n\n /*\n * Define the size of the array and create the data space for fixed\n * size dataset.\n */\n hsize_t rank = RANK;\n hsize_t dimsf[rank];\n for (int i = 0; i < rank; i++) {\n dimsf[i] = tensor.dimension(i);\n\n }\n H5::DataSpace dataspace(rank, dimsf);\n\n /*\n * Define datatype for the data in the file.\n * We will store little endian INT numbers.\n */\n H5::IntType datatype(H5::PredType::NATIVE_INT);\n datatype.setOrder(H5T_ORDER_LE);\n\n /*\n * Create a new dataset within the file using defined dataspace and\n * datatype and default dataset creation properties.\n */\n H5::DataSet dataset = file.createDataSet(\"tensor\", datatype, dataspace);\n\n /*\n * Write the data to the dataset using default memory space, file\n * space, and transfer properties.\n */\n int* data = static_cast(tensor.data());\n dataset.write(data, H5::PredType::NATIVE_INT);\n } // end of try block\n\n // catch failure caused by the H5File operations\n catch(H5::FileIException error) {\n error.printError();\n return false;\n }\n\n // catch failure caused by the DataSet operations\n catch(H5::DataSetIException error) {\n error.printError();\n return false;\n }\n\n // catch failure caused by the DataSpace operations\n catch(H5::DataSpaceIException error) {\n error.printError();\n return false;\n }\n\n // catch failure caused by the DataSpace operations\n catch(H5::DataTypeIException error) {\n error.printError();\n return false;\n }\n\n return true;\n}\n\n/** \\brief Read all files in a directory matching the given extension.\n * \\param[in] directory path to directory\n * \\param[out] files read file paths\n * \\param[in] extension extension to filter for\n */\nvoid read_directory(const boost::filesystem::path directory, std::map& files, const std::string extension = \".off\") {\n\n files.clear();\n boost::filesystem::directory_iterator end;\n\n for (boost::filesystem::directory_iterator it(directory); it != end; ++it) {\n if (it->path().extension().string() == extension) {\n int number = std::stoi(it->path().filename().string());\n files.insert(std::pair(number, it->path()));\n }\n }\n}\n\n/** \\brief Main entrance point of the script.\n * Expects one parameter, the path to the corresponding config file in config/.\n */\nint main(int argc, char** argv) {\n boost::program_options::options_description desc(\"Allowed options\");\n desc.add_options()\n (\"help\", \"produce help message\")\n (\"mode\", boost::program_options::value()->default_value(\"occ\"), \"operation mode, 'occ' or 'sdf'\")\n (\"input\", boost::program_options::value(), \"input, either single OFF file or directory containing OFF files where the names correspond to integers (zero padding allowed) and are consecutively numbered starting with zero\")\n (\"height\", boost::program_options::value()->default_value(32), \"height of volume, corresponding to y-axis (=up)\")\n (\"width\", boost::program_options::value()->default_value(32), \"width of volume, corresponding to x-axis (=right\")\n (\"depth\", boost::program_options::value()->default_value(32), \"depth of volume, corresponding to z-axis (=forward)\")\n (\"center\", boost::program_options::bool_switch()->default_value(false), \"by default, the top-left-front corner is used for SDF computation; if instead the voxel centers should be used, set this flag\")\n (\"output\", boost::program_options::value(), \"output file, will be a HDF5 file containing either a N x C x height x width x depth tensor or a C x height x width x depth tensor, where N is the number of files and C=2 the number of channels, N is discarded if only a single file is processed; should have the .h5 extension\");\n\n boost::program_options::positional_options_description positionals;\n positionals.add(\"mode\", 1);\n positionals.add(\"input\", 1);\n positionals.add(\"output\", 1);\n\n boost::program_options::variables_map parameters;\n boost::program_options::store(boost::program_options::command_line_parser(argc, argv).options(desc).positional(positionals).run(), parameters);\n boost::program_options::notify(parameters);\n\n if (parameters.find(\"help\") != parameters.end()) {\n std::cout << desc << std::endl;\n return 0;\n }\n\n std::string mode = parameters[\"mode\"].as();\n if (mode == \"occ\") {\n std::cout << \"Voxelizing occupancy grids.\" << std::endl;\n }\n else if (mode == \"sdf\") {\n std::cout << \"Voxelizing SDFs.\" << std::endl;\n }\n else {\n std::cout << \"Invalid mode, choose from occ or sdf.\" << std::endl;\n return 1;\n }\n\n boost::filesystem::path input(parameters[\"input\"].as());\n if (!boost::filesystem::is_directory(input) && !boost::filesystem::is_regular_file(input)) {\n std::cout << \"Input is neither directory nor file.\" << std::endl;\n return 1;\n }\n\n boost::filesystem::path output(parameters[\"output\"].as());\n if (boost::filesystem::is_regular_file(output)) {\n std::cout << \"Output file already exists; overwriting.\" << std::endl;\n }\n\n VoxelizationMode voxelization_mode;\n if (parameters[\"center\"].as()) {\n voxelization_mode = VoxelizationMode::CENTER;\n std::cout << \"Using the top-left-front voxel corner for voxelization.\" << std::endl;\n }\n else {\n voxelization_mode = VoxelizationMode::CORNER;\n std::cout << \"Using the voxel center for voxelization.\" << std::endl;\n }\n\n int height = parameters[\"height\"].as();\n int width = parameters[\"width\"].as();\n int depth = parameters[\"depth\"].as();\n\n std::cout << \"Voxelizing into \" << height << \" x \" << width << \" x \" << depth << \" (height x width x depth).\" << std::endl;\n\n if (boost::filesystem::is_regular_file(input)) {\n Mesh mesh;\n bool success = Mesh::from_off(input.string(), mesh);\n\n if (!success) {\n std::cout << \"Could not read \" << input << \".\" << std::endl;\n return 1;\n }\n\n std::cout << \"Read \" << input << \".\" << std::endl;\n\n if (mode == \"sdf\") {\n Eigen::Tensor tensor(height, width, depth);\n\n mesh.voxelize_sdf(tensor, voxelization_mode);\n std::cout << \"Voxelized \" << input << \".\" << std::endl;\n\n bool success = write_float_hdf5<3>(output.string(), tensor);\n\n if (!success) {\n std::cout << \"Could not write \" << output << \".\" << std::endl;\n return 1;\n }\n }\n if (mode == \"occ\") {\n Eigen::Tensor tensor(height, width, depth);\n tensor.setZero();\n\n mesh.voxelize_occ(tensor, voxelization_mode);\n std::cout << \"Voxelized \" << input << \".\" << std::endl;\n\n bool success = write_int_hdf5<3>(output.string(), tensor);\n\n if (!success) {\n std::cout << \"Could not write \" << output << \".\" << std::endl;\n return 1;\n }\n }\n\n std::cout << \"Wrote \" << output << \".\" << std::endl;\n std::cout << \"The output is a \" << height << \" x \" << width << \" x \" << depth << \" tensor.\" << std::endl;\n }\n else {\n std::map input_files;\n read_directory(input, input_files);\n\n if (input_files.size() <= 0) {\n std::cout << \"Could not find any OFF files in the input directory.\" << std::endl;\n return 1;\n }\n\n std::cout << \"Read \" << input_files.size() << \" files.\" << std::endl;\n\n if (mode == \"sdf\") {\n Eigen::Tensor tensor(input_files.size(), height, width, depth);\n\n int i = 0;\n for (std::map::iterator it = input_files.begin(); it != input_files.end(); it++) {\n Mesh mesh;\n bool success = Mesh::from_off(it->second.string(), mesh);\n\n if (!success) {\n std::cout << \"Could not read \" << it->second << \".\" << std::endl;\n return 1;\n }\n\n Eigen::Tensor slice(height, width, depth);\n mesh.voxelize_sdf(slice, voxelization_mode);\n tensor.chip(i, 0) = slice;\n std::cout << \"Voxelized \" << it->second << \" (\" << (i + 1) << \" of \" << input_files.size() << \").\" << std::endl;\n\n i++;\n }\n\n bool success = write_float_hdf5<4>(output.string(), tensor);\n\n if (!success) {\n std::cout << \"Could not write \" << output << \".\" << std::endl;\n return 1;\n }\n }\n if (mode == \"occ\") {\n Eigen::Tensor tensor(input_files.size(), height, width, depth);\n tensor.setZero();\n\n int i = 0;\n for (std::map::iterator it = input_files.begin(); it != input_files.end(); it++) {\n Mesh mesh;\n bool success = Mesh::from_off(it->second.string(), mesh);\n\n if (!success) {\n std::cout << \"Could not read \" << it->second << \".\" << std::endl;\n return 1;\n }\n\n Eigen::Tensor slice(height, width, depth);\n slice.setZero();\n\n mesh.voxelize_occ(slice, voxelization_mode);\n tensor.chip(i, 0) = slice;\n std::cout << \"Voxelized \" << it->second << \" (\" << (i + 1) << \" of \" << input_files.size() << \").\" << std::endl;\n\n i++;\n }\n\n bool success = write_int_hdf5<4>(output.string(), tensor);\n\n if (!success) {\n std::cout << \"Could not write \" << output << \".\" << std::endl;\n return 1;\n }\n }\n\n std::cout << \"Wrote \" << output << \".\" << std::endl;\n std::cout << \"The output is a \" << input_files.size() << \" x \" << height << \" x \" << width << \" x \" << depth << \" tensor.\" << std::endl;\n }\n\n return 0;\n}", "meta": {"hexsha": "cd5a9f67bb4d34302687e63c2b33356fd1fd0151", "size": 22925, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "main.cpp", "max_stars_repo_name": "FairyPig/mesh-voxelization", "max_stars_repo_head_hexsha": "5f597c421cb04857f0959725627b02c1949d31ad", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2019-08-02T12:20:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-07T08:43:48.000Z", "max_issues_repo_path": "main.cpp", "max_issues_repo_name": "FairyPig/mesh-voxelization", "max_issues_repo_head_hexsha": "5f597c421cb04857f0959725627b02c1949d31ad", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.cpp", "max_forks_repo_name": "FairyPig/mesh-voxelization", "max_forks_repo_head_hexsha": "5f597c421cb04857f0959725627b02c1949d31ad", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2019-08-02T12:20:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-07T08:43:52.000Z", "avg_line_length": 29.811443433, "max_line_length": 341, "alphanum_fraction": 0.6026608506, "num_tokens": 6366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6001883735630721, "lm_q2_score": 0.4960938294709195, "lm_q1q2_score": 0.29774974864482723}} {"text": "/*********************************************************************************\n * OKVIS - Open Keyframe-based Visual-Inertial SLAM\n * Copyright (c) 2015, Autonomous Systems Lab / ETH Zurich\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n * * Neither the name of Autonomous Systems Lab / ETH Zurich nor the names of\n * its contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n *\n * Created on: Jan 7, 2014\n * Author: Stefan Leutenegger (s.leutenegger@imperial.ac.uk)\n *********************************************************************************/\n\n/**\n * @file odeHybrid.hpp\n * @brief Runge Kutta based IMU forward and backward propagation with an extended IMU model.\n * developed from ode.hpp in okvis.\n * @author Jianzhu Huai\n */\n\n#ifndef INCLUDE_SWIFT_VIO_ODE_HYBRID_HPP_\n#define INCLUDE_SWIFT_VIO_ODE_HYBRID_HPP_\n\n#include \n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace swift_vio {\nnamespace ode {\nconst int kNavErrorStateDim = 9;\n// Note this function assume that the W frame has z axis along the negative gravity.\n// This fact is used in computing velocity in the W frame.\n__inline__ void evaluateContinuousTimeOde(\n const Eigen::Vector3d& gyr, const Eigen::Vector3d& acc, double g,\n const Eigen::Vector3d& p_WS_W, const Eigen::Quaterniond& q_WS,\n const okvis::SpeedAndBiases& sb,\n const ImuErrorModel& iem, Eigen::Vector3d& p_WS_W_dot,\n Eigen::Vector4d& q_WS_dot, okvis::SpeedAndBiases& sb_dot,\n Eigen::MatrixXd* F_c_ptr = 0) {\n Eigen::Vector3d omega_S;\n Eigen::Vector3d acc_S;\n iem.estimate(gyr, acc, &omega_S, &acc_S);\n\n // nonlinear states\n // start with the pose\n p_WS_W_dot = sb.head<3>();\n\n // now the quaternion\n Eigen::Vector4d dq;\n q_WS_dot.head<3>() = 0.5 * omega_S;\n q_WS_dot[3] = 0.0;\n Eigen::Matrix3d C_WS = q_WS.toRotationMatrix();\n\n // the rest is straightforward\n // consider Earth's radius. Model the Earth as a sphere, since we neither\n // know the position nor yaw (except if coupled with GPS and magnetometer).\n Eigen::Vector3d G =\n -p_WS_W - Eigen::Vector3d(0, 0, 6371009); // vector to Earth center\n sb_dot.head<3>() = (C_WS * acc_S + g * G.normalized()); // s\n // biases\n sb_dot.tail<6>().setZero();\n\n // linearized system:\n if (F_c_ptr) {\n F_c_ptr->setZero();\n F_c_ptr->block<3, 3>(0, 6) = Eigen::Matrix3d::Identity();\n // F_c_ptr->block<3, 3>(3, 9) -= C_WS;\n F_c_ptr->block<3, 3>(6, 3) -= okvis::kinematics::crossMx(C_WS * acc_S);\n // F_c_ptr->block<3, 3>(6, 12) -= C_WS;\n Eigen::Matrix N = Eigen::Matrix::Zero();\n N.block<3, 3>(3, 0) = C_WS;\n N.block<3, 3>(6, 3) = C_WS;\n int colsF = F_c_ptr->cols();\n Eigen::Matrix dwaB_dbgbaSTS;\n iem.dwa_B_dbgbaSTS(omega_S, acc_S, dwaB_dbgbaSTS);\n F_c_ptr->block(0, 9, 9, colsF - 9) = N * dwaB_dbgbaSTS.rightCols(colsF - 9);\n }\n}\n\n// p_WS_W, q_WS, sb are states at k\n/* * covariance error states $\\Delta y = \\Delta[\\mathbf{p}_{WS}^W,\n\\Delta\\mathbf{\\alpha}, \\Delta\\mathbf{v}_S^W,\n * \\Delta\\mathbf{b_g}, \\Delta\\mathbf{b_a}, \\Delta\\mathbf{Tg}, \\Delta\\mathbf{Ts},\n\\Delta\\mathbf{Ta}]$\n * $\\tilde{R}_s^w=(I-[\\delta\\alpha^w]_\\times)R_s^w$\n * this DEFINITION OF ROTATION ERROR is the same in Mingyang Li's later\npublications, okvis, and huai ION GNSS+ 2015 $y = [\\mathbf{p}_{WS}^W,\n\\mathbf{q}_S^W, \\mathbf{v}_S^W, \\mathbf{b_g}, \\mathbf{b_a}]$ $u =\n[\\mathbf{\\omega}_{WS}^S,\\mathbf{a}^S]$ $h = t_{n+1}-t_n$\n$\\mathbf{p}_{WS}^W \\oplus = \\mathbf{p}_{WS}^W +$\n$\\mathbf{v}_{WS}^W \\oplus = \\mathbf{v}_{WS}^W +$\n$\\mathbf{q}_{S}^W \\oplus \\mathbf{\\omega}_{WS}^S h/2 =\n\\mathbf{q}_{S}^W\\begin{bmatrix}\ncos(\\mathbf{\\omega}_{WS}^S h/2) \\\\\nsin(\\mathbf{\\omega}_{WS}^S\nh/2)\\frac{\\mathbf{\\omega}_{WS}^S/2}{\\vert\\mathbf{\\omega}_{WS}^S/2\\vert}\n\\end{bmatrix}$\n\n$k_1 = f(t_n,y_n,u_n)$\n$k_2 = f(t_n+h/2,y_n\\oplus k_1 h/2 ,(u_n +u_{n+1})/2)$\n$k_3 = f(t_n+h/2,y_n\\oplus k_2 h/2 ,(u_n +u_{n+1})/2)$\n$k_4 = f(t_n+h,y_n\\oplus k_3 h , u_{n+1})$\n$y_{n+1}=y_n\\oplus\\left(h(k_1 +2k_2 +2k_3 +k_4)/6 \\right )$\nCaution: provide both F_tot_ptr(e.g., identity) and P_ptr(e.g., zero matrix) if\ncovariance is to be computed\n*/\n__inline__ void integrateOneStep_RungeKutta(\n const Eigen::Vector3d& gyr_0, const Eigen::Vector3d& acc_0,\n const Eigen::Vector3d& gyr_1, const Eigen::Vector3d& acc_1, double g,\n double sigma_g_c, double sigma_a_c, double sigma_gw_c, double sigma_aw_c,\n double dt, Eigen::Vector3d& p_WS_W, Eigen::Quaterniond& q_WS,\n okvis::SpeedAndBiases& sb, const ImuErrorModel& iem,\n Eigen::MatrixXd* P_ptr = 0,\n Eigen::MatrixXd* F_tot_ptr = 0) {\n Eigen::Vector3d k1_p_WS_W_dot;\n Eigen::Vector4d k1_q_WS_dot;\n\n okvis::SpeedAndBiases k1_sb_dot;\n int covRows = 0;\n Eigen::MatrixXd k1_F_c;\n Eigen::MatrixXd k2_F_c;\n Eigen::MatrixXd k3_F_c;\n Eigen::MatrixXd k4_F_c;\n Eigen::MatrixXd* k1_F_c_ptr = nullptr;\n Eigen::MatrixXd* k2_F_c_ptr = nullptr;\n Eigen::MatrixXd* k3_F_c_ptr = nullptr;\n Eigen::MatrixXd* k4_F_c_ptr = nullptr;\n if (P_ptr || F_tot_ptr) {\n covRows = P_ptr ? P_ptr->rows() : F_tot_ptr->rows();\n k1_F_c.resize(covRows, covRows);\n k2_F_c.resize(covRows, covRows);\n k3_F_c.resize(covRows, covRows);\n k4_F_c.resize(covRows, covRows);\n k1_F_c_ptr = &k1_F_c;\n k2_F_c_ptr = &k2_F_c;\n k3_F_c_ptr = &k3_F_c;\n k4_F_c_ptr = &k4_F_c;\n }\n\n evaluateContinuousTimeOde(gyr_0, acc_0, g, p_WS_W, q_WS, sb, iem,\n k1_p_WS_W_dot, k1_q_WS_dot, k1_sb_dot, k1_F_c_ptr);\n\n Eigen::Vector3d p_WS_W1 = p_WS_W;\n Eigen::Quaterniond q_WS1 = q_WS;\n okvis::SpeedAndBiases sb1 = sb;\n // state propagation:\n p_WS_W1 += k1_p_WS_W_dot * 0.5 * dt;\n Eigen::Quaterniond dq;\n double theta_half = k1_q_WS_dot.head<3>().norm() * 0.5 * dt;\n double sinc_theta_half = okvis::kinematics::sinc(theta_half);\n double cos_theta_half = cos(theta_half);\n dq.vec() = sinc_theta_half * k1_q_WS_dot.head<3>() * 0.5 * dt;\n dq.w() = cos_theta_half;\n q_WS1 = q_WS * dq;\n sb1 += k1_sb_dot * 0.5 * dt;\n\n Eigen::Vector3d k2_p_WS_W_dot;\n Eigen::Vector4d k2_q_WS_dot;\n okvis::SpeedAndBiases k2_sb_dot;\n evaluateContinuousTimeOde(0.5 * (gyr_0 + gyr_1), 0.5 * (acc_0 + acc_1), g,\n p_WS_W1, q_WS1, sb1, iem, k2_p_WS_W_dot,\n k2_q_WS_dot, k2_sb_dot, k2_F_c_ptr);\n\n Eigen::Vector3d p_WS_W2 = p_WS_W;\n Eigen::Quaterniond q_WS2 = q_WS;\n okvis::SpeedAndBiases sb2 = sb;\n // state propagation:\n p_WS_W2 += k2_p_WS_W_dot * 0.5 * dt;\n theta_half = k2_q_WS_dot.head<3>().norm() * 0.5 * dt;\n sinc_theta_half = okvis::kinematics::sinc(theta_half);\n cos_theta_half = cos(theta_half);\n dq.vec() = sinc_theta_half * k2_q_WS_dot.head<3>() * 0.5 * dt;\n dq.w() = cos_theta_half;\n // std::cout<().norm() * dt;\n sinc_theta_half = okvis::kinematics::sinc(theta_half);\n cos_theta_half = cos(theta_half);\n dq.vec() = sinc_theta_half * k3_q_WS_dot.head<3>() * dt;\n dq.w() = cos_theta_half;\n // std::cout<() +\n 2 * (k2_q_WS_dot.head<3>() + k3_q_WS_dot.head<3>()) +\n k4_q_WS_dot.head<3>()) *\n dt / 6.0;\n theta_half = theta_half_vec.norm();\n sinc_theta_half = okvis::kinematics::sinc(theta_half);\n cos_theta_half = cos(theta_half);\n dq.vec() = sinc_theta_half * theta_half_vec;\n dq.w() = cos_theta_half;\n q_WS = q_WS * dq;\n sb += (k1_sb_dot + 2 * (k2_sb_dot + k3_sb_dot) + k4_sb_dot) * dt / 6.0;\n\n q_WS.normalize(); // do not accumulate errors!\n\n if (F_tot_ptr) {\n // compute state transition matrix, note $\\frac{d\\Phi(t, t_0)}{dt}=\n // F(t)\\Phi(t, t_0)$\n Eigen::MatrixXd& F_tot = *F_tot_ptr;\n const Eigen::MatrixXd& J1 = k1_F_c;\n const Eigen::MatrixXd J2 =\n k2_F_c * (Eigen::MatrixXd::Identity(covRows, covRows) + 0.5 * dt * J1);\n const Eigen::MatrixXd J3 =\n k3_F_c * (Eigen::MatrixXd::Identity(covRows, covRows) + 0.5 * dt * J2);\n const Eigen::MatrixXd J4 =\n k4_F_c * (Eigen::MatrixXd::Identity(covRows, covRows) + dt * J3);\n Eigen::MatrixXd F = Eigen::MatrixXd::Identity(covRows, covRows) +\n dt * (J1 + 2 * (J2 + J3) + J4) / 6.0;\n F_tot =\n (F * F_tot)\n .eval(); // F is $\\Phi(t_k, t_{k-1})$, F_tot is $\\Phi(t_k, t_{0})$\n\n if (P_ptr) {\n Eigen::MatrixXd& cov = *P_ptr;\n cov = F * (cov * F.transpose()).eval();\n\n // add process noise\n const double Q_g = sigma_g_c * sigma_g_c * dt;\n const double Q_a = sigma_a_c * sigma_a_c * dt;\n const double Q_gw = sigma_gw_c * sigma_gw_c * dt;\n const double Q_aw = sigma_aw_c * sigma_aw_c * dt;\n cov(3, 3) += Q_g;\n cov(4, 4) += Q_g;\n cov(5, 5) += Q_g;\n cov(6, 6) += Q_a;\n cov(7, 7) += Q_a;\n cov(8, 8) += Q_a;\n cov(9, 9) += Q_gw;\n cov(10, 10) += Q_gw;\n cov(11, 11) += Q_gw;\n cov(12, 12) += Q_aw;\n cov(13, 13) += Q_aw;\n cov(14, 14) += Q_aw;\n\n // force symmetric\n // huai: this may help keep cov positive semi-definite after propagation\n cov = 0.5 * cov + 0.5 * cov.transpose().eval();\n }\n }\n}\n\n/* p_WS_W, q_WS, sb are states at k+1, dt= t(k+1) -t(k)\n$y = [\\mathbf{p}_{WS}^W, \\mathbf{q}_S^W, \\mathbf{v}_S^W, \\mathbf{b_g},\n\\mathbf{b_a}]$ $u = [\\mathbf{\\omega}_{WS}^S,\\mathbf{a}^S]$ $h = t_{n}-t_{n+1}$\n$\\mathbf{p}_{WS}^W \\oplus = \\mathbf{p}_{WS}^W +$\n$\\mathbf{v}_{WS}^W \\oplus = \\mathbf{v}_{WS}^W +$\n$\\mathbf{q}_{S}^W \\oplus \\mathbf{\\omega}_{WS}^S h/2 =\n\\mathbf{q}_{S}^W\\begin{bmatrix}\ncos(\\mathbf{\\omega}_{WS}^S h/2) \\\\\nsin(\\mathbf{\\omega}_{WS}^S\nh/2)\\frac{\\mathbf{\\omega}_{WS}^S/2}{\\vert\\mathbf{\\omega}_{WS}^S/2\\vert}\n\\end{bmatrix}$\n\n$k_1 = f(t_{n+1},y_{n+1},u_{n+1})$\n$k_2 = f(t_{n+1}+h/2,y_{n+1}\\oplus k_1 h/2 ,(u_n +u_{n+1})/2)$\n$k_3 = f(t_{n+1}+h/2,y_{n+1}\\oplus k_2 h/2 ,(u_n +u_{n+1})/2)$\n$k_4 = f(t_n,y_{n+1}\\oplus k_3 h , u_{n})$\n$y_{n}=y_{n+1}\\oplus\\left(h(k_1 +2k_2 +2k_3 +k_4)/6 \\right )$\n*/\n__inline__ void integrateOneStepBackward_RungeKutta(\n const Eigen::Vector3d& gyr_0, const Eigen::Vector3d& acc_0,\n const Eigen::Vector3d& gyr_1, const Eigen::Vector3d& acc_1, double g,\n double sigma_g_c, double sigma_a_c, double sigma_gw_c, double sigma_aw_c,\n double dt, Eigen::Vector3d& p_WS_W, Eigen::Quaterniond& q_WS,\n okvis::SpeedAndBiases& sb, const ImuErrorModel& iem,\n Eigen::MatrixXd* P_ptr = 0,\n Eigen::MatrixXd* F_tot_ptr = 0) {\n Eigen::Vector3d k1_p_WS_W_dot;\n Eigen::Vector4d k1_q_WS_dot;\n okvis::SpeedAndBiases k1_sb_dot;\n\n int covRows = 0;\n Eigen::MatrixXd k1_F_c;\n Eigen::MatrixXd k2_F_c;\n Eigen::MatrixXd k3_F_c;\n Eigen::MatrixXd k4_F_c;\n Eigen::MatrixXd* k1_F_c_ptr = nullptr;\n Eigen::MatrixXd* k2_F_c_ptr = nullptr;\n Eigen::MatrixXd* k3_F_c_ptr = nullptr;\n Eigen::MatrixXd* k4_F_c_ptr = nullptr;\n if (P_ptr || F_tot_ptr) {\n covRows = P_ptr ? P_ptr->rows() : F_tot_ptr->rows();\n k1_F_c.resize(covRows, covRows);\n k2_F_c.resize(covRows, covRows);\n k3_F_c.resize(covRows, covRows);\n k4_F_c.resize(covRows, covRows);\n k1_F_c_ptr = &k1_F_c;\n k2_F_c_ptr = &k2_F_c;\n k3_F_c_ptr = &k3_F_c;\n k4_F_c_ptr = &k4_F_c;\n }\n\n evaluateContinuousTimeOde(gyr_1, acc_1, g, p_WS_W, q_WS, sb, iem,\n k1_p_WS_W_dot, k1_q_WS_dot, k1_sb_dot, k1_F_c_ptr);\n\n Eigen::Vector3d p_WS_W1 = p_WS_W;\n Eigen::Quaterniond q_WS1 = q_WS;\n okvis::SpeedAndBiases sb1 = sb;\n // state propagation:\n p_WS_W1 -= k1_p_WS_W_dot * 0.5 * dt;\n Eigen::Quaterniond dq;\n double theta_half = -k1_q_WS_dot.head<3>().norm() * 0.5 * dt;\n double sinc_theta_half = okvis::kinematics::sinc(theta_half);\n double cos_theta_half = cos(theta_half);\n dq.vec() = -sinc_theta_half * k1_q_WS_dot.head<3>() * 0.5 * dt;\n dq.w() = cos_theta_half;\n q_WS1 = q_WS * dq;\n sb1 -= k1_sb_dot * 0.5 * dt;\n\n Eigen::Vector3d k2_p_WS_W_dot;\n Eigen::Vector4d k2_q_WS_dot;\n okvis::SpeedAndBiases k2_sb_dot;\n evaluateContinuousTimeOde(0.5 * (gyr_0 + gyr_1), 0.5 * (acc_0 + acc_1), g,\n p_WS_W1, q_WS1, sb1, iem, k2_p_WS_W_dot,\n k2_q_WS_dot, k2_sb_dot, k2_F_c_ptr);\n\n Eigen::Vector3d p_WS_W2 = p_WS_W;\n Eigen::Quaterniond q_WS2 = q_WS;\n okvis::SpeedAndBiases sb2 = sb;\n // state propagation:\n p_WS_W2 -= k2_p_WS_W_dot * 0.5 * dt;\n theta_half = -k2_q_WS_dot.head<3>().norm() * 0.5 * dt;\n sinc_theta_half = okvis::kinematics::sinc(theta_half);\n cos_theta_half = cos(theta_half);\n dq.vec() = -sinc_theta_half * k2_q_WS_dot.head<3>() * 0.5 * dt;\n dq.w() = cos_theta_half;\n // std::cout<().norm() * dt;\n sinc_theta_half = okvis::kinematics::sinc(theta_half);\n cos_theta_half = cos(theta_half);\n dq.vec() = -sinc_theta_half * k3_q_WS_dot.head<3>() * dt;\n dq.w() = cos_theta_half;\n // std::cout<() +\n 2 * (k2_q_WS_dot.head<3>() + k3_q_WS_dot.head<3>()) +\n k4_q_WS_dot.head<3>()) *\n dt / 6.0;\n theta_half = theta_half_vec.norm();\n sinc_theta_half = okvis::kinematics::sinc(theta_half);\n cos_theta_half = cos(theta_half);\n dq.vec() = sinc_theta_half * theta_half_vec;\n dq.w() = cos_theta_half;\n q_WS = q_WS * dq;\n sb -= (k1_sb_dot + 2 * (k2_sb_dot + k3_sb_dot) + k4_sb_dot) * dt / 6.0;\n\n q_WS.normalize(); // do not accumulate errors!\n\n if (F_tot_ptr) {\n assert(false); // the following section is not well perused and tested\n // compute state transition matrix, note $\\frac{d\\Phi(t, t_0)}{dt}=\n // F(t)\\Phi(t, t_0)$\n Eigen::MatrixXd& F_tot = *F_tot_ptr;\n const Eigen::MatrixXd& J1 = k1_F_c;\n const Eigen::MatrixXd J2 =\n k2_F_c * (Eigen::MatrixXd::Identity(covRows, covRows) - 0.5 * dt * J1);\n const Eigen::MatrixXd J3 =\n k3_F_c * (Eigen::MatrixXd::Identity(covRows, covRows) - 0.5 * dt * J2);\n const Eigen::MatrixXd J4 =\n k4_F_c * (Eigen::MatrixXd::Identity(covRows, covRows) - dt * J3);\n Eigen::MatrixXd F = Eigen::MatrixXd::Identity(covRows, covRows) -\n dt * (J1 + 2 * (J2 + J3) + J4) / 6.0;\n F_tot = (F * F_tot).eval();\n\n if (P_ptr) {\n Eigen::MatrixXd& cov = *P_ptr;\n cov = F * (cov * F.transpose()).eval();\n\n // add process noise\n const double Q_g = sigma_g_c * sigma_g_c * dt;\n const double Q_a = sigma_a_c * sigma_a_c * dt;\n const double Q_gw = sigma_gw_c * sigma_gw_c * dt;\n const double Q_aw = sigma_aw_c * sigma_aw_c * dt;\n cov(3, 3) += Q_g;\n cov(4, 4) += Q_g;\n cov(5, 5) += Q_g;\n cov(6, 6) += Q_a;\n cov(7, 7) += Q_a;\n cov(8, 8) += Q_a;\n cov(9, 9) += Q_gw;\n cov(10, 10) += Q_gw;\n cov(11, 11) += Q_gw;\n cov(12, 12) += Q_aw;\n cov(13, 13) += Q_aw;\n cov(14, 14) += Q_aw;\n\n // force symmetric - TODO: is this really needed here?\n // cov = 0.5 * cov + 0.5 * cov.transpose().eval();\n }\n }\n}\n} // namespace ode\n} // namespace swift_vio\n\n#endif // INCLUDE_SWIFT_VIO_ODE_HYBRID_HPP_\n", "meta": {"hexsha": "dc023c8a1398700bf39bbe48d1b67a3a14d967e3", "size": 18519, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "okvis_ceres/include/swift_vio/imu/odeHybrid.hpp", "max_stars_repo_name": "wbl1997/okvis", "max_stars_repo_head_hexsha": "65e30d6ab25380d65c96c665485148e2ab55e93e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-03-26T15:31:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T15:31:53.000Z", "max_issues_repo_path": "okvis_ceres/include/swift_vio/imu/odeHybrid.hpp", "max_issues_repo_name": "wbl1997/okvis", "max_issues_repo_head_hexsha": "65e30d6ab25380d65c96c665485148e2ab55e93e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "okvis_ceres/include/swift_vio/imu/odeHybrid.hpp", "max_forks_repo_name": "wbl1997/okvis", "max_forks_repo_head_hexsha": "65e30d6ab25380d65c96c665485148e2ab55e93e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-08-01T16:49:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-14T09:00:03.000Z", "avg_line_length": 38.7426778243, "max_line_length": 92, "alphanum_fraction": 0.6389113883, "num_tokens": 6576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.49609382947091957, "lm_q1q2_score": 0.29774974154926315}} {"text": "/*\n * sinker.cpp\n * pybg\n *\n * Created by BART MOSLEY on 8/12/12.\n * Copyright 2012 BG Research LLC. All rights reserved.\n *\n */\n\n\n#include \n\n#include \n\n#include \n\nusing namespace std;\nusing namespace QuantLib;\nusing namespace bondgeek;\n\n\n#if defined(QL_ENABLE_SESSIONS)\nnamespace QuantLib {\n Integer sessionId() { return 0; }\n}\n#endif\n\nvoid showCashFlows(Bond &bnd)\n{\n Leg fixedLeg = bnd.cashflows();\n \n cout << endl << \"Fixed Leg: \" << endl;\n Leg::iterator fxIt;\n Date cfDate;\n double cfAmt;\n for (fxIt=fixedLeg.begin(); fxIt < fixedLeg.end(); fxIt++) \n {\n cfDate = (*fxIt)->date();\n cfAmt = (*fxIt)->amount();\n cout << cfDate << \" | \" << cfAmt << endl;\n }\n \n}\n\nvoid showAssetSwapCashFlows(AssetSwap &aswap)\n{\n Leg fixedLeg = aswap.bondLeg();\n Leg floatLeg = aswap.floatingLeg();\n \n Date cfDate;\n double cfAmt;\n \n cout << endl << \"Fixed Leg: \" << endl;\n Leg::iterator fxIt;\n for (fxIt=fixedLeg.begin(); fxIt < fixedLeg.end(); fxIt++) \n {\n cfDate = (*fxIt)->date();\n cfAmt = (*fxIt)->amount();\n cout << cfDate << \" | \" << cfAmt << endl;\n }\n cout << endl << \"Floating Leg: \" << endl;\n Leg::iterator flIt;\n for (flIt=floatLeg.begin(); flIt < floatLeg.end(); flIt++) \n {\n cfDate = (*flIt)->date();\n cfAmt = (*flIt)->amount();\n cout << cfDate << \" | \" << cfAmt << endl;\n }\n \n}\n\nvoid showRedemptions(Bond &bnd)\n{\n Leg fixedLeg = bnd.redemptions();\n \n cout << endl << \"Redemptions: \" << endl;\n Leg::iterator fxIt;\n Date cfDate;\n double cfAmt;\n for (fxIt=fixedLeg.begin(); fxIt < fixedLeg.end(); fxIt++) \n {\n cfDate = (*fxIt)->date();\n cfAmt = (*fxIt)->amount();\n cout << cfDate << \" | \" << cfAmt << endl;\n }\n \n}\n\nvoid showNotionals(Bond &bnd)\n{\n std::vector bnd_notionals = bnd.notionals();\n \n cout << endl << \"Notionals: \" << endl;\n std::vector::iterator it;\n int notional_count = 0;\n for (it=bnd_notionals.begin(); it < bnd_notionals.end(); it++) {\n notional_count++;\n cout << notional_count << \": \" << *it << endl;\n }\n \n}\n\n\nint main (int argc, char * const argv[]) \n{\n \n Date today = Date(16,October,2007);\n Settings::instance().evaluationDate() = today;\n\n cout << endl << \"Today: \" << today << endl;\n cout << \"Price with a bg curve \" << endl;\n string depotenors[] = {\"1W\", \"1M\", \"3M\", \"6M\", \"9M\"};\n double depospots[] = {0.0018400, 0.0023050, 0.0041825,\n 0.0070765, 0.0086780};\n string swaptenors[] = {\"2y\", \"3y\", \"5y\", \"10Y\", \n \"15Y\", \"20Y\", \"30Y\"};\n double swapspots[] = {.0040100, 0.0042600, 0.0077300, 0.0106595, \n 0.0211555, 0.02310205, 0.0247007};\n \n cout << \"Test with new curve \" << endl;\n RateHelperCurve usdLiborCurve = RateHelperCurve(USDLiborCurve(\"3M\"));\n usdLiborCurve.update(depotenors, \n depospots, \n 5,\n swaptenors, \n swapspots,\n 7,\n today);\n \n boost::shared_ptr discEngine = \\\n createPriceEngine(\n usdLiborCurve.discountingTermStructure()\n );\n \n // set up the callable bond\n Real coupon = .06;\n Date maturity(15, September,2012);\n Date maturity1(15, September, 2011);\n Date maturity0(15, September, 2010);\n \n Date dated(16,September,2004);\n \n Natural settlementDays = 3; // Bloomberg OAS1 settle is Oct 19, 2007\n Frequency frequency = Semiannual;\n \n Calendar bondCalendar = UnitedStates(UnitedStates::GovernmentBond);\n DayCounter bondDayCounter = ActualActual(ActualActual::Bond);\n \n Real faceAmount = 100.0; // Notional amount\n Real redemption = 100.0; // Amount paid on redemption\n \n BusinessDayConvention accrualConvention = Unadjusted;\n BusinessDayConvention paymentConvention = Unadjusted;\n \n cout << endl << endl\n << \"Generic Bond\"\n << endl;\n SinkingFundBond bnd(coupon,\n maturity,\n std::vector(1, faceAmount),\n Annual,\n dated,\n bondCalendar,\n settlementDays,\n bondDayCounter,\n frequency,\n redemption,\n faceAmount,\n accrualConvention,\n paymentConvention\n );\n \n showCashFlows(bnd);\n\n cout << \"\\n\\none year shorter\" << endl;\n SinkingFundBond bnd0(coupon,\n maturity0,\n std::vector(1, faceAmount),\n Annual,\n dated,\n bondCalendar,\n settlementDays,\n bondDayCounter,\n frequency,\n redemption,\n faceAmount,\n accrualConvention,\n paymentConvention\n );\n \n showCashFlows(bnd0);\n \n cout << \"\\n\\ntwo years shorter\" << endl;\n SinkingFundBond bnd1(coupon,\n maturity1,\n std::vector(1, faceAmount),\n Annual,\n dated,\n bondCalendar,\n settlementDays,\n bondDayCounter,\n frequency,\n redemption,\n faceAmount,\n accrualConvention,\n paymentConvention\n );\n showCashFlows(bnd1);\n\n /* Sinkfing fund amortization:\n \n notionals start at par on the dated date and end at zero on maturity.\n redemptions are the prices redemption prices (pct of par, e.g. 101.)\n\n */\n \n double sf_sch[] = {\n 40000, 40000, 40000, 40000, 40000, 40000,\n 40000, 40000, 40000, 40000, 40000, 40000,\n 40000\n };\n int sf_num = 3;\n Frequency sf_freq = Annual;\n \n std::vector sf_bal;\n sf_bal.assign(sf_sch, sf_sch+sf_num);\n \n Real rval = 100.;\n \n cout << endl << endl\n << \"Amortizing Generic Bond \"\n << endl;\n SinkingFundBond bnd2(coupon,\n maturity,\n sf_bal,\n sf_freq,\n dated,\n bondCalendar,\n settlementDays,\n bondDayCounter,\n frequency,\n rval,\n faceAmount,\n accrualConvention,\n paymentConvention\n ); \n \n // show the results\n showCashFlows(bnd2);\n \n bnd0.setPricingEngine(discEngine);\n bnd1.setPricingEngine(discEngine);\n bnd.setPricingEngine(discEngine);\n bnd2.setPricingEngine(discEngine);\n \n double prc0 = bnd0.cleanPrice();\n double prc1 = bnd1.cleanPrice();\n double prc = bnd.cleanPrice();\n double prc2 = bnd2.cleanPrice();\n \n cout << endl << \"Pricing component bonds\" << endl \n << \"priced0: \" << prc0 << endl \n << \"priced1: \" << prc1 << endl \n << \"priced: \" << prc << endl\n << \"avg price: \" << (prc0+prc1+prc)/3. << endl\n << endl \n << \"priced sinking fund bond: \" << prc2 << endl;\n cout << \"cf yield: \" << bnd.toYield(prc2) << endl;\n \n return 0;\n}\n\n", "meta": {"hexsha": "e11c562986893a1296ed9cc46b6ce2b72bf55155", "size": 7900, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "examples/sinker.cpp", "max_stars_repo_name": "bondgeek/pybg", "max_stars_repo_head_hexsha": "046a25074b78409c6d29302177aeac581ade90d1", "max_stars_repo_licenses": ["Unlicense", "MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-03-14T05:39:15.000Z", "max_stars_repo_stars_event_max_datetime": "2017-03-14T05:39:15.000Z", "max_issues_repo_path": "examples/sinker.cpp", "max_issues_repo_name": "bondgeek/pybg", "max_issues_repo_head_hexsha": "046a25074b78409c6d29302177aeac581ade90d1", "max_issues_repo_licenses": ["Unlicense", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/sinker.cpp", "max_forks_repo_name": "bondgeek/pybg", "max_forks_repo_head_hexsha": "046a25074b78409c6d29302177aeac581ade90d1", "max_forks_repo_licenses": ["Unlicense", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.9377289377, "max_line_length": 106, "alphanum_fraction": 0.4856962025, "num_tokens": 1933, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.600188359260205, "lm_q2_score": 0.49609382947091946, "lm_q1q2_score": 0.2977497415492631}} {"text": "\n/*\n * Prover.cpp\n *\n * Created on: 26.10.2010\n * Author: stephaniebayer\n */\n\n#include \"Prover.h\"\n\n#include\n#include \"Cipher_elg.h\"\n#include \"G_q.h\"\n#include \"Mod_p.h\"\n#include \"Functions.h\"\n#include \"ElGammal.h\"\n#include \"func_pro.h\"\n#include \"fft.h\"\n#include\n\n#include \n#include \nNTL_CLIENT\n\nextern G_q H;\nextern ElGammal El;\n\nProver::Prover() {\n\t// TODO Auto-generated constructor stub\n\n}\n\nProver::Prover(vector* >* Cin, vector* >* Rin, vector* >* >* piin, vector num, ZZ genq){\n\n\t// set the dimensions of the row and columns according to the user input\n\tm = num[1]; //number of rows\n\tn = num[2]; //number of columns\n\tC = Cin; //sets the reencrypted cipertexts to the input\n\tR = Rin; //sets the random elements to the input\n\tpi = piin; // sets the permutation to the input\n\n\n\tfft *fft_new = new fft;\n\t//o is a root of unity\n\to = fft_new->r_o_u(genq, m, H.get_ord());\n\n\n\tA = new vector* >(m);\n\tfunc_pro::set_A(A,pi, m, n);\n\n\t//Allocate the storage needed for the vectors\n\tchal_x6 = new vector(2*m); //x6, x6^2, ... challenges from round 6\n\tchal_y6 = new vector(n); //y6, y6^2, ... challenges form round 6\n\tchal_x8 = new vector(2*m +1); //x8, x8^2, ... challenges from round 8\n\n\t//Allocate the storage needed for the vectors\n\tc_A = new vector(m+1); //commitments to the rows in A\n\tr_A = new vector(m+1); //random elements used for the commitments\n\n\tD = new vector* >(m+1); //vector containing in the first row random values and in all others y*A(ij) + B(ij)-z\n\tD_h = new vector* >(m); //Vector of the Hadamare products of the rows in D\n\tD_s = new vector* >(m+1); //Shifted rows of D_h\n\td = new vector(n); //containing random elements to proof product of D_hm\n\tDelta = new vector(n); //containing random elements to proof product of D_hm\n\td_h = new vector(n); // vector containing the last row of D-h\n\n\tr_D_h = new vector(m);//random elements for commitments to D_h\n\tc_D_h = new vector(m+2);//commitments to the rows in D_h\n\n\tB = new vector* >(m);//matrix of permuted exponents, exponents are x2^i, i=1, ..N\n\tB_0 = new vector(n); //vector containing random exponents\n\tr_B = new vector(m); //random elements used to commit to T\n\tc_B = new vector(m); //vector of commitments to rows in T\n\ta = new vector(2*m); //elements used for reencryption in round 5\n\tr_a = new vector(2*m); //random elements to commit to elements in a\n\tc_a = new vector(2*m); //commitments to elements a\n\tE = new vector(2*m); //\n\trho_a = new vector(2*m); //\n\n\tDl = new vector(2*m+1); //bilinear_map(Y_pi, U, chal_t)\n\tr_Dl = new vector(2*m+1); //random elements to commit to the C_ls\n\tc_Dl = new vector(2*m +1); //commitments to the C_ls\n\n\td_bar = new vector(n);// chal_x8*D_h(m-1) +d\n\tDelta_bar = new vector(n);//chal_x8*d_h+Delta\n\tD_h_bar = new vector(n);//sum over the rows in D_h\n\n\tB_bar = new vector(n); // sum over the rows in T multiplied by chal^i\n\n\tA_bar = new vector(n); //sum over the rows in Y times the challenges\n\tD_s_bar = new vector(n); // sum over the rows in U times thes challenges\n\n}\n//Destructor deletes all pointers and frees the storage\nProver::~Prover() {\n\tdelete chal_x6;\n\tdelete chal_y6;\n\tdelete chal_x8;\n\tdelete c_A;\n\tdelete r_A;\n\n\tFunctions::delete_vector(D);\n\tFunctions::delete_vector(D_h);\n\tFunctions::delete_vector(D_s);\n\tdelete d;\n\tdelete Delta;\n\tdelete d_h;\n\n\tdelete r_D_h;\n\tdelete c_D_h;\n\tFunctions::delete_vector(B);\n\tdelete B_0;\n\tdelete r_B;\n\tdelete c_B;\n\tdelete a;\n\tdelete r_a;\n\tdelete c_a;\n\tdelete rho_a;\n\tdelete Dl;\n\tdelete r_Dl;\n\tdelete c_Dl;\n\n\tdelete D_h_bar;\n\tdelete d_bar;\n\tdelete Delta_bar;\n\tdelete B_bar;\n\tdelete A_bar;\n\tdelete D_s_bar;\n}\n\n\n\n//round_1 picks random elements and commits to the rows of Y\nstring Prover::round_1(){\n\tlong i;\n\tstring name;\n\ttime_t rawtime;\n\ttime ( &rawtime );\n\n\t//calculates commitments to rows of Y\n\tname = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\tost<<\"commitments to A and random values \"<at(i)<< \" \";\n\t}\n\treturn name;\n\n}\n\n//round_3, permuted the exponents in s, picks random elements and commits to values\nstring Prover::round_3(string in_name){\n\tlong i;\n\tZZ x2;\n\tvector* >* chal_x2 = new vector* >(m);\n\n\tstring name;\n\ttime_t rawtime;\n\ttime ( &rawtime );\n\n\t//reads in values of s\n\tifstream ist(in_name.c_str());\n\tif(!ist) cout<<\"Can't open \"<< in_name;\n\tist >> x2;\n\tname = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\tost<<\"x ist \"<at(i) <<\" \";\n\t}\n\n\tFunctions::delete_vector(chal_x2);\n\treturn name;\n}\n\n//round_5a calculates Y_pi and the commitments to the vectors alpha, W\nvoid Prover::round_5a(){\n\tlong i;\n\tZZ temp, t; //temporary variables\n\tvector* r = new vector(n);\n\tvector* v_z = new vector(n); //row containing the challenge alpha\n\tZZ ord = H.get_ord();\n\ttime_t rawtime;\n\ttime ( &rawtime );\n\n\t//calculate for each value in the first m rows in D: y* A_ij + A_ij -z\n\tfunc_pro::set_D(D, A,B, chal_z4, chal_y4);\n\n\t//Set the matrix D_h as the Hadamard product of the rows in D\n\tfunc_pro::set_D_h(D_h, D);\n\n\tfor( i=0; iat(i) = chal_z4; //fills the vector z with the challenge z\n\t\tNegateMod(r->at(i),to_ZZ(1),ord);\n\t}\n\n\t//Sets the additional row in D to contain -1\n\tstring name = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\tost<<\"Last row in D ist -1 \"<at(m) = r;\n\t//random number to commit to last row in A\n\tost<<\"r_A to commit to last row in A ist \"<<0<at(m) = 0;\n\n\t//calculate commitment to\n\tost<<\"commitment to vector z\"<* e = 0;\n\tdouble tstart, tstop, ttime;\n\n\t//calculates the value R_t as sum(T(ij)*r(ij));\n\tfunc_pro::set_Rb(B,R,R_b);\n\n\ttstart = (double)clock()/CLOCKS_PER_SEC;\n\t\te= calculate_e();\n\ttstop = (double)clock()/CLOCKS_PER_SEC;\n\tttime= tstop-tstart;\n\t//cout << \"To calculate the di's took \" << ttime << \" second(s).\" << endl;\n\n\tcalculate_E(e);\n\tdelete e;\n}\n\nstring Prover::round_5(string in_name ){\n\tlong i;\n\tstring name;\n\ttime_t rawtime;\n\ttime ( &rawtime );\n\n\t//reads the values out of the file\n\tifstream ist(in_name.c_str());\n\tif(!ist) cout<<\"Can't open \"<< in_name;\n\tist>> chal_z4;\n\tist >> chal_y4;\n\n\t name = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\tost<<\"z \"<at(i)<< \" \";\n\t}\n\tost << c_B0<< \"\\n \";\n\tfor (i = 0; i<2*m ; i++){\n\t\tost << c_a ->at(i)<< \" \";\n\t}\n\tost << \"\\n\";\n\tfor (i = 0; i<2*m ; i++){\n\t\tost << E ->at(i)<< \" \";\n\t}\n\n\tdelete E;\n\treturn name;\n}\n\nvoid Prover::round_7a(){\n\t//Set the rows in D_s as D_s(i) = chal_t_1^i+1*D_h(i) for iat(i)*chal_y6) for j=n+i-l and commits to the values\n\tfunc_pro::commit_Dl(c_Dl,Dl, r_Dl, D, D_s, chal_y6, o);\n\n\t//commitments to D(0) and D_s(m)\n\tost<<\"commitment to D(0) and D_s(m) \"<at(0),r_D0,c_D0);\n\tFunctions::commit(D_s->at(m), r_Dm, c_Dm);\n\n\t//commitments to prove that the product over the elements in D_h->at(m) is the desired product of n *y + x2n -z\n\tost<<\"commitment to d \"<>chal_x6->at(i);\n\t}\n\tfor (i = 0; i> chal_y6->at(i);\n\t}\n\n\tround_7a();\n\tround_7b();\n\n\n\t//Set name of the output file and open stream\n\tname = \"round_7 \";\n\tname = name + ctime(&rawtime);\n\n\n\tofstream ost(name.c_str());\n\tfor (i = 0; i<=l ; i++){\n\t\tost << c_Dl ->at(i)<< \" \";\n\t}\n\tost << \"\\n\";\n\tost<at(i)<<\" \";\n\t}\n\tost <<\"\\n\";\n\n\tost<< r_B_bar;\n\tost <<\"\\n\";\n\n\tost<< a_bar;\n\tost <<\"\\n\";\n\n\tost<< r_a_bar;\n\tost <<\"\\n\";\n\n\tost<< rho_bar;\n\n\treturn name;\n}\n\nvoid Prover::round_9a(){\n\n\t//Calculate D_h_bar = sum(chal^i*D_h(row(i)))\n\tfunc_pro::calculate_D_h_bar(D_h_bar,D_h,chal_x8);\n\n\t//calculate r_Dh_bar = sum(chal^i*r_Dh_bar(i)), opening to prove correctness of D_h\n\tfunc_pro::calculate_r_Dh_bar(r_D_h, chal_x8, r_Dh_bar);\n\n\t//calculate d_bar, r_d_bar, Delta_bar, r_Delta_bar, openings to prove product over elements in D_h->at(m-1)\n\tfunc_pro::calculate_dbar_rdbar(D_h, chal_x8, d_bar,d,r_D_h, r_d, r_d_bar);\n\tfunc_pro::calculate_Deltabar_rDeltabar(d_h, chal_x8, Delta_bar, Delta, r_d_h, r_Delta, r_Delta_bar);\n}\n\nvoid Prover::round_9b(){\n\t//A_bar and r_A_bar, openings to prove permutation in D\n\tfunc_pro::calculate_A_bar(D, A_bar, chal_x8);\n\tfunc_pro::calculate_r_A_bar(r_D0, r_A, r_B, chal_x8, r_z, chal_y4, r_A_bar);\n\n\t//D_s_bar and r_Ds_bar, openings to prove correctness of D_s\n\tfunc_pro::calculate_D_s_bar(D_s, D_s_bar, chal_x8);\n\tfunc_pro::calculate_r_Ds_bar(r_D_h, chal_x6, chal_x8, r_Ds_bar, r_Dm);\n\n\t//sum of the random values used to commit to the Dl's, to prover correctness of them\n\tfunc_pro::calculate_r_Dl_bar(r_Dl, chal_x8, r_Dl_bar);\n}\n\nstring Prover::round_9(string in_name){\n\tlong i;\n\tstring name;\n\ttime_t rawtime;\n\ttime ( &rawtime );\n\n\t//reads the values out of the file\n\tifstream ist(in_name.c_str());\n\tif(!ist) cout<<\"Can't open \"<< in_name;\n\t//reads the vector e\n\tfor (i = 0; i<(signed) chal_x8->size(); i++){\n\t\tist >> chal_x8->at(i);\n\t}\n\n\tname = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\n\tost<<\"chal_x8 \"<< chal_x8->at(0)<at(i)<<\" \";\n\t}\n\tost <<\"\\n\";\n\tost<< r_Dh_bar;\n\tost <<\"\\n\";\n\n\tfor(i=0; iat(i)<<\" \";\n\t}\n\tost<<\"\\n\";\n\tost<< r_d_bar <<\"\\n\";\n\n\tfor(i=0; iat(i)<<\" \";\n\t}\n\tost<<\"\\n\";\n\tost<at(i)<<\" \";\n\t}\n\tost<<\"\\n\";\n\tost<at(i)<<\" \";\n\t}\n\tost<<\"\\n\";\n\tost<at(pos)->at(0), B_0->at(0));\n\tfor (i = 1; iat(pos)->at(i), B_0->at(i));\n\t\tCipher_elg::mult(temp,temp, temp_1);\n\t}\n\n\treturn temp;\n}\n\nCipher_elg Prover::calculate_e_2(long k){\n\tlong i,j,l;\n\tCipher_elg temp, temp_1;\n\tZZ mod = H.get_mod();\n\n\ttemp=Cipher_elg(1,1,mod);\n\tfor (i = 1; i<=m; i++){\n\t\tl = k-m+i;\n\t\tif((l>0) & (l<=m)){\n\t\t\tfor(j = 0; jat(i-1)->at(j), B->at(l-1)->at(j));\n\t\t\t\tCipher_elg::mult(temp,temp,temp_1);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn temp;\n}\n\nvector* Prover::calculate_e(){\n\tlong k,l;\n\tCipher_elg temp, temp_1;\n\tvector* e = new vector(2*m);\n\n\tstring name = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\tost<<\"calculate the product of the diagonlas, values E \"<at(0)= calculate_e_1(m-1);\n\tost<at(0)<<\" \";\n\n\tl=m-1;\n\tfor (k =1; k<=l; k++){\n\t\ttemp_1 = calculate_e_1(m-k-1);\n\t\ttemp = calculate_e_2(k);\n\t\tCipher_elg::mult(temp,temp,temp_1);\n\t\te->at(k) = temp;\n\t\tost<at(k)<<\" \";\n\t}\n\tl=2*m-1;\n\tfor (k = m; k<=l; k++){\n\t\te->at(k) = calculate_e_2(k);\n\t\tost<at(k)<<\" \";\n\t}\n\tost<* e){\n\tlong i,l;\n\tMod_p t;\n\tMod_p gen = H.get_gen();\n\tZZ ord = H.get_ord();\n\tl=2*m;\n\tstring name = \"example.txt\";\n\tofstream ost;\n\tost.open(name.c_str(),ios::app);\n\tost<<\"reencrypt values in e, pick random rho \"<at(i)= RandomBnd(ord);\n\t\tost<at(i)<<\" \";\n\t}\n\tost<at(m),R_b,ord);\n\tost<<\"rho(m) = -R_b m\"<at(m)<<\" \"<at(i));\n\t\t E->at(i) = El.encrypt(t,rho_a->at(i))*e->at(i);\n\t\t ost<at(i)<\n#include \n\n#include \n#include \n\n#include \"heom/command_line.hpp\"\n#include \"heom/common.hpp\"\n#include \"heom/handle_main_exception.hpp\"\n#include \"heom/hierarchy_graph.hpp\"\n#include \"heom/hierarchy_mask.hpp\"\n#include \"heom/hierarchy_norm.hpp\"\n#include \"heom/instance.hpp\"\n#include \"heom/make_file_observer_list.hpp\"\n#include \"heom/ocl_config.hpp\"\n#include \"heom/ode.hpp\"\n#include \"heom/population_dynamics_config.hpp\"\n#include \"heom/population_dynamics_solver.hpp\"\n\nnamespace bmt = ::heom::bmt;\nnamespace num = ::heom::num;\nnamespace ocl = ::heom::ocl;\nusing num::int_t;\nusing num::real_t;\n\nint main(int argc, char* argv[])\n{\n\t// start runtime measurement\n\tbmt::timer app_timer;\n\n\t// output compile-time configuration\n\tstd::cout << \"-------------------- Compile-Time Configuration ------------\" << std::endl;\n\theom::write_compile_config(std::cout);\n\tstd::cout << \"------------------------------------------------------------\" << std::endl;\n\n\tstd::exception_ptr eptr;\n\ttry {\n\t\t// command line parsing\n\t\theom::command_line command_line { argc, argv };\n\n\t\t// parse config files\n\t\tstd::cout << \"Parsing OpenCL configuration from file: \" << command_line.ocl_config_filename() << std::endl;\n\t\theom::ocl_config ocl_config(command_line.ocl_config_filename());\n\t\tstd::cout << \"Parsing HEOM configuration from file: \" << command_line.heom_config_filename() << std::endl;\n\t\theom::population_dynamics_config heom_config(command_line.heom_config_filename());\n\n\t\theom::hierarchy_graph complete_graph(heom_config.baths_number(), heom_config.baths_matsubaras(), heom_config.system_ado_depth());\n\n\t\theom::instance heom_instance(heom_config, heom::sites_to_states_mode_t::identity, complete_graph);\n\t\theom_instance.set_hierarchy_top(heom_config.population_dynamics_rho_init().data());\n\n\t\tusing stepper_t = num::meta_stepper; // uses solver_stepper_type from config\n\t\tusing solver_t = heom::population_dynamics_solver;\n\n\t\t// create a solver from configuration and instance\n\t\tconst ocl::nd_range ocl_nd_range {\n\t\t\t\t{}, // offset\n\t\t {1, static_cast(heom_instance.matrices())}, // global size\n\t\t {1, 1} // local size\n\t\t\t};\n\n\t\tsolver_t solver(ocl_config, ocl_nd_range, heom_config, heom_instance);\n\t\tstd::cout << \"-------------------- OpenCL Runtime Configuration ----------\" << std::endl;\n\t\tsolver.write_ocl_runtime_config(std::cout);\n\t\tstd::cout << \"------------------------------------------------------------\" << std::endl;\n\n\t\t// with create_hierarchy_mask we create mask corresponding to configured filtering strategy, then update solver\n\t\t// NOTE: .data() returns pointer to mask_t array\n\t\theom::hierarchy_mask hierarchy_mask = heom::create_hierarchy_mask(heom_config.filtering_strategy(), complete_graph, heom_config.baths_matsubaras(), heom_config.filtering_first_layer());\n\t\tsolver.update_hierarchy_mask(hierarchy_mask.data());\n\n\t\tstd::cout << \"-------------------- Hierarchy Mask Counter ----------------\" << std::endl;\n\t\theom::write_hierarchy_mask_stats(hierarchy_mask, std::cout);\n\t\tstd::cout << \"------------------------------------------------------------\" << std::endl;\n\n\t\t// setup output\n\t\theom::observer_list observer_list = heom::make_file_observer_list(heom_config, complete_graph, solver);\n\t\tobserver_list.observe(0.0);\n\n\t\t// run the solver, print output every n steps\n\t\tint_t iterations = heom_config.solver_steps() / heom_config.program_observe_steps();\n\t\tint_t steps_per_iteration = heom_config.program_observe_steps();\n\t\tint_t total_steps = iterations * heom_config.program_observe_steps();\n\n\t\tfor (int_t i = 0; i < iterations; ++i) {\n\t\t\t// propagate\n\t\t\tsolver.step_forward(steps_per_iteration);\n\n\t\t\t// after propagation, we are at:\n\t\t\tconst auto current_step = (i + 1) * steps_per_iteration;\n\t\t\tconst real_t current_time = current_step * heom_config.solver_step_size();\n\n\t\t\t// observe\n//\t\t\tsolver.get_top_result(result_buffer_top);\n\t\t\tobserver_list.observe(current_time);\n\n\t\t\t// update status\n\t\t\theom::write_progress(current_step - 1, total_steps, \"Calculation population dynamics: \", std::cout);\n\t\t}\n\n\t\t// output benchmark results\n\t\tstd::cout << \"-------------------- Solver Runtime Summary ----------------\" << std::endl;\n\t\tsolver.write_runtime_summary(std::cout);\n\t\tstd::cout << \"------------------------------------------------------------\" << std::endl;\n\t\tstd::cout << \"-------------------- Memory Summary ------------------------\" << std::endl;\n\t\tstd::cout << \"local hierarchy buffer size: \"\n\t\t << boost::format(\"%11.2f MiB\\n\") % (heom_instance.size_hierarchy_byte() / 1024.0 / 1024.0);\n\t\tstd::cout << \"local instance size: \"\n\t\t << boost::format(\"%11.2f MiB\\n\") % (heom_instance.allocated_byte() / 1024.0 / 1024.0);\n\t\tstd::cout << \"max. heap via aligned::allocate(..): \"\n\t\t << boost::format(\"%11.2f MiB\") % (heom::memory::aligned::instance().allocated_byte_max() / 1024.0 / 1024.0)\n\t\t << \" (\"\n\t\t << boost::format(\"count: %6i\") % heom::memory::aligned::instance().allocations_max()\n\t\t << ')' << std::endl;\n\t\tstd::cout << \"max. OpenCL buffer allocations: \"\n\t\t << boost::format(\"%11.2f MiB\") % (solver.ocl_helper().allocated_byte_max() / 1024.0 / 1024.0)\n\t\t << \" (\"\n\t\t\t << boost::format(\"count: %6i\") % solver.ocl_helper().allocations_max()\n\t\t\t << ')' << std::endl;\n\t\tstd::cout << \"------------------------------------------------------------\" << std::endl;\n\n\t} catch (...) {\n\t\teptr = std::current_exception();\n\t}\n\tint ret = heom::handle_main_exception(eptr);\n\n\t// print application runtime\n\tstd::cout << \"main(): application runtime: \" << boost::format(\"%11.2f\") % std::chrono::duration_cast(bmt::duration(app_timer.elapsed())).count() << \" s\" << std::endl;\n\n\treturn ret;\n}\n", "meta": {"hexsha": "a97b75ee03828749c0236eb9f474215f928a3451", "size": 6130, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "dm-heom/src/app_population_dynamics.cpp", "max_stars_repo_name": "noma/dm-heom", "max_stars_repo_head_hexsha": "85c94f947190064d21bd38544094731113c15412", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2019-07-28T01:02:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T04:01:36.000Z", "max_issues_repo_path": "dm-heom/src/app_population_dynamics.cpp", "max_issues_repo_name": "noma/dm-heom", "max_issues_repo_head_hexsha": "85c94f947190064d21bd38544094731113c15412", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dm-heom/src/app_population_dynamics.cpp", "max_forks_repo_name": "noma/dm-heom", "max_forks_repo_head_hexsha": "85c94f947190064d21bd38544094731113c15412", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-04-04T15:20:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-24T15:16:40.000Z", "avg_line_length": 44.1007194245, "max_line_length": 187, "alphanum_fraction": 0.6425774878, "num_tokens": 1544, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746213017459, "lm_q2_score": 0.47268347662043286, "lm_q1q2_score": 0.2976840574842258}} {"text": "/* CirKit: A circuit toolkit\n * Copyright (C) 2009-2015 University of Bremen\n * Copyright (C) 2015-2017 EPFL\n *\n * Permission is hereby granted, free of charge, to any person\n * obtaining a copy of this software and associated documentation\n * files (the \"Software\"), to deal in the Software without\n * restriction, including without limitation the rights to use,\n * copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following\n * conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n * OTHER DEALINGS IN THE SOFTWARE.\n */\n\n#include \"rcbdd_synthesis.hpp\"\n#include \"synthesis_utils_p.hpp\"\n\n#include \n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define timer timer_class\n#include \n#undef timer\n\n#include \n\nnamespace cirkit\n{\n\nenum Direction {\n ChangeLeft = 0,\n ChangeRight\n};\n\nint Cudd_bddPickOneCubeForRCBDD( DdManager * ddm, DdNode * node, char * repr)\n{\n DdNode *N, *T, *E;\n DdNode *one, *bzero;\n char dir;\n int i;\n\n if ( repr == nullptr || node == nullptr ) return 0;\n\n /* The constant 0 function has no on-set cubes. */\n one = DD_ONE(ddm);\n bzero = Cudd_Not(one);\n if (node == bzero) return 0;\n\n for ( i = 0; i < ddm->size; i++ ) repr[i] = 2;\n\n for (;;)\n {\n if ( node == one ) break;\n\n N = Cudd_Regular(node);\n\n T = cuddT(N); E = cuddE(N);\n if ( Cudd_IsComplement( node ) )\n {\n\t T = Cudd_Not(T); E = Cudd_Not(E);\n }\n if ( T == bzero )\n {\n\t repr[N->index] = 0;\n\t node = E;\n }\n else if ( E == bzero )\n {\n\t repr[N->index] = 1;\n\t node = T;\n }\n else\n {\n if ( N->index % 3 == 1 )\n {\n repr[N->index] = repr[N->index - 1];\n node = repr[N->index] ? T : E;\n }\n else\n {\n dir = (char) ((Cudd_Random( ddm ) & 0x2000) >> 13);\n repr[N->index] = dir;\n node = dir ? T : E;\n }\n }\n }\n return 1;\n}\n\nint pick_one_cube_for_rcbdd( BDD node, char * repr )\n{\n return Cudd_bddPickOneCubeForRCBDD( node.manager(), node.getNode(), repr );\n}\n\nstruct rcbdd_synthesis_manager\n{\n rcbdd_synthesis_manager( const rcbdd& _cf, circuit& _circ )\n : cf( _cf ),\n circ( _circ ),\n insert_position( 0u )\n {\n f = _cf.chi();\n\n circ.set_lines( _cf.num_vars() );\n\n std::vector inputs( _cf.num_vars(), _cf.constant_value() ? \"1\" : \"0\" );\n boost::copy( cf.input_labels(), inputs.end() - _cf.num_inputs() );\n circ.set_inputs( inputs );\n\n std::vector outputs( _cf.num_vars(), \"-\" );\n boost::copy( cf.output_labels(), outputs.begin() );\n circ.set_outputs( outputs );\n\n std::vector constants( _cf.num_vars(), constant() );\n std::fill( constants.begin(), constants.end() - _cf.num_inputs(), _cf.constant_value() );\n circ.set_constants( constants );\n\n std::vector garbage( _cf.num_vars(), true );\n std::fill( garbage.begin(), garbage.begin() + _cf.num_outputs(), false );\n circ.set_garbage( garbage );\n\n node_count += f.nodeCount();\n }\n\n void set_var(unsigned v)\n {\n _var = v;\n\n left_f = cf.manager().bddZero();\n right_f = cf.manager().bddZero();\n }\n\n void compute_cofactors()\n {\n n = cf.cofactor(f, _var, false, false);\n pp = cf.cofactor(f, _var, true, false);\n np = cf.cofactor(f, _var, false, true);\n p = cf.cofactor(f, _var, true, true);\n\n nx = cf.remove_ys(n);\n ppx = cf.remove_ys(pp);\n npx = cf.remove_ys(np);\n px = cf.remove_ys(p);\n\n ny = cf.remove_xs(n);\n ppy = cf.remove_xs(pp);\n npy = cf.remove_xs(np);\n py = cf.remove_xs(p);\n }\n\n void apply_gates(const BDD& lf, const BDD& rf)\n {\n left_f ^= lf;\n right_f ^= rf;\n\n BDD gate_left = cf.create_from_gate(_var, lf);\n BDD gate_right = cf.create_from_gate(_var, cf.move_ys_to_xs(rf));\n f = cf.compose(cf.compose(gate_left, f), gate_right);\n node_count += f.nodeCount();\n }\n\n void only_left_gate_shortcut()\n {\n BDD chi_prime = f;\n\n // Copy y_var to x_var\n chi_prime = chi_prime.ExistAbstract(cf.x(_var)) & cf.x(_var).Xnor(cf.y(_var));\n\n // Check whether chi' is reversible\n if (mpz_class(chi_prime.CountMinterm(2u * cf.num_vars())) == pow2(cf.num_vars())\n && cf.remove_ys(chi_prime) == cf.manager().bddOne()\n && cf.remove_xs(chi_prime) == cf.manager().bddOne())\n {\n BDD lf = cf.remove_ys(!f & chi_prime).ExistAbstract(cf.x(_var));\n apply_gates(lf, cf.manager().bddZero());\n }\n }\n\n void resolve_one_cycles()\n {\n // Via F_n\n compute_cofactors();\n\n //BDD lf = (!nx & ppx) ^ (!px & npx);\n BDD lf = ppx & npx;\n\n apply_gates(lf, cf.manager().bddZero());\n\n compute_cofactors();\n\n BDD rf = ppy & npy;\n\n apply_gates(cf.manager().bddZero(), rf);\n\n // // Via F_p\n // compute_cofactors();\n\n // lf = !px & npx;\n // rf = !py & ppy;\n\n // apply_gates(lf, rf);\n }\n\n void resolve_two_cycles()\n {\n // Via F_p\n compute_cofactors();\n\n BDD _f = ppy & p & npx;\n BDD lf = cf.remove_ys(_f);\n BDD rf = cf.remove_xs(_f);\n\n apply_gates(lf, rf);\n\n // Via F_n\n compute_cofactors();\n\n _f = npy & n & ppx;\n lf = cf.remove_ys(_f);\n rf = cf.remove_xs(_f);\n\n apply_gates(lf, rf);\n }\n\n\n void cycle_step()\n {\n compute_cofactors();\n\n std::vector variables;\n boost::push_back(variables, cf.xs());\n boost::push_back(variables, cf.ys());\n\n // Pick an arbitrary cube from pp\n BDD cube;\n\n if ( pp != cf.manager().bddZero() )\n {\n cube = pp.PickOneMinterm(variables);\n }\n else\n {\n cube = ( !cf.remove_xs( f ) & !cf.remove_ys( f ) & cf.x( _var) & !cf.y( _var ) ).PickOneMinterm( variables );\n f |= cube;\n }\n char change = ChangeLeft;\n\n BDD lf = cf.manager().bddZero();\n BDD rf = cf.manager().bddZero();\n BDD cube_part;\n char *scube = new char[3u * cf.num_vars()];\n\n ++access;\n\n do\n {\n if (change == ChangeLeft)\n {\n // Update left gate\n cube_part = cf.remove_ys(cube).ExistAbstract(cf.x(_var));\n lf |= cube_part;\n //change = CHANGE_RIGHT;\n cube = !cf.x(_var) & cube_part & f;\n }\n else\n {\n cube_part = cf.remove_xs(cube).ExistAbstract(cf.y(_var));\n rf |= cube_part;\n //change = CHANGE_LEFT;\n cube = cf.y(_var) & cube_part & f;\n }\n\n /* Cube is not part of the function? */\n if (cube == cf.manager().bddZero())\n {\n BDD unused_outputs = !cf.remove_xs(f);\n BDD unused_inputs = !cf.remove_ys(f);\n\n BDD icube, ocube;\n\n if (change == ChangeLeft)\n {\n icube = !cf.x(_var) & cube_part;\n\n ocube = cf.manager().bddOne();\n if ((unused_outputs & cf.y(_var)) != cf.manager().bddZero())\n {\n (unused_outputs & cf.y(_var)).PickOneCube(scube);\n }\n else\n {\n unused_outputs.PickOneCube(scube);\n }\n for (unsigned i = 0u; i < cf.num_vars(); ++i)\n {\n ocube &= (scube[3u * i + 1u] == 1) ? cf.y(i) : !cf.y(i);\n }\n }\n else\n {\n ocube = cf.y(_var) & cube_part;\n\n icube = cf.manager().bddOne();\n if ((unused_inputs & !cf.x(_var)) != cf.manager().bddZero())\n {\n (unused_inputs & !cf.x(_var)).PickOneCube(scube);\n }\n else\n {\n unused_inputs.PickOneCube(scube);\n }\n for (unsigned i = 0u; i < cf.num_vars(); ++i)\n {\n icube &= (scube[3u * i] == 1) ? cf.x(i) : !cf.x(i);\n }\n }\n\n cube = icube & ocube;\n f |= cube;\n\n compute_cofactors();\n }\n\n change = ((char)1u - change);\n ++access;\n } while ( ( cube & ( pp | np ) ) == cf.manager().bddZero() );\n\n /* Cleanup */\n delete[] scube;\n\n apply_gates(lf, rf);\n }\n\n void resolve_k_cycles()\n {\n while (cf.cofactor(f, _var, true, false) != cf.manager().bddZero() || cf.cofactor(f, _var, false, true) != cf.manager().bddZero())\n {\n compute_cofactors();\n\n /* special case #P' is 0 and #N' is not zero, then swap */\n if ( pp == cf.manager().bddZero() && np != cf.manager().bddZero() )\n {\n apply_gates( cf.manager().bddOne(), cf.manager().bddOne() );\n }\n\n if ( false /*verbose*/ )\n {\n std::cout << \"#N: \" << cf.cofactor( f, _var, false, false ).CountMinterm( 2u * cf.num_vars() ) << \" \"\n << \"#P': \" << cf.cofactor( f, _var, true, false ).CountMinterm( 2u * cf.num_vars() ) << \" \"\n << \"#N': \" << cf.cofactor( f, _var, false, true ).CountMinterm( 2u * cf.num_vars() ) << \" \"\n << \"#P: \" << cf.cofactor( f, _var, true, true ).CountMinterm( 2u * cf.num_vars() ) << std::endl;\n }\n\n cycle_step();\n }\n }\n\n typedef std::tuple<\n bool, // p1[_var] value\n std::function, // compute fc\n unsigned, // scube offset\n std::function, // update f\n std::function // update circ\n > resolve_cycles_configuration_t;\n\n /* DISABLE FOR NOW\n resolve_cycles_configuration_t resolve_x = std::make_tuple(\n true,\n []( rcbdd_synthesis_manager* manager ) {\n BDD fc = manager->ppx & manager->cf.move_xs_to_tmp( manager->npx );\n for ( unsigned j = 0u; j < manager->_var; ++j )\n {\n fc &= ( manager->cf.x( j ).Xnor( manager->cf.z( j ) ) );\n }\n return fc;\n },\n 0u,\n []( rcbdd_synthesis_manager* manager, BDD gcirc, BDD f ) { return manager->cf.compose( gcirc, f ); },\n []( circuit& circ, const circuit& c ) { append_circuit( circ, c ); } );\n\n resolve_cycles_configuration_t resolve_y = std::make_tuple(\n false,\n []( rcbdd_synthesis_manager* manager ) {\n BDD fc = manager->ppy & manager->cf.move_ys_to_tmp( manager->npy );\n for ( unsigned j = 0u; j < manager->_var; ++j )\n {\n fc &= ( manager->cf.y( j ).Xnor( manager->cf.z( j ) ) );\n }\n return fc;\n },\n 1u,\n []( rcbdd_synthesis_manager* manager, BDD gcirc, BDD f ) { return manager->cf.compose( f, gcirc ); },\n []( circuit& circ, const circuit& c ) { prepend_circuit( circ, c ); } );\n */\n\n void resolve_cycles_with_transpositions( const resolve_cycles_configuration_t& configuration )\n {\n if ( false /*verbose*/ )\n {\n std::cout << boost::format( \"[i] resolve cycles for var %d\" ) % _var << std::endl;\n }\n\n while ( cf.cofactor( f, _var, true, false ) != cf.manager().bddZero() ||\n cf.cofactor( f, _var, false, true ) != cf.manager().bddZero() )\n {\n compute_cofactors();\n\n /* Extract two cubes and save them into bitset */\n boost::dynamic_bitset<> p1( cf.num_vars() ), p2( cf.num_vars() );\n\n p1[_var] = std::get<0>( configuration );\n p2[_var] = !std::get<0>( configuration );\n\n char *scube = new char[3u * cf.num_vars()];\n\n BDD fc = std::get<1>( configuration )( this );\n\n if ( !smart_pickcube )\n {\n fc.PickOneCube( scube );\n }\n else\n {\n pick_one_cube_for_rcbdd( fc, scube );\n }\n\n for ( unsigned i = 0u; i < cf.num_vars(); ++i )\n {\n if ( i == _var ) continue;\n p1[i] = scube[3u * i + std::get<2>( configuration )];\n p2[i] = scube[3u * i + 2u];\n }\n\n delete[] scube;\n\n /* Create circuit for p1 and p2 */\n if ( verbose )\n {\n //std::cout << \"[i] realize transposition (\" << p1 << \" \" << p2 << \")\" << std::endl;\n }\n circuit c( cf.num_vars() );\n pattern_to_circuit( c, p1, p2 );\n if ( verbose )\n {\n //std::cout << \"[i] result: \" << std::endl << c;\n }\n\n /* Apply circuit to f */\n BDD gcirc = cf.create_from_circuit( c );\n f = std::get<3>( configuration )( this, gcirc, f );\n std::get<4>( configuration )( circ, c );\n }\n }\n\n void add_toffoli_gate( const cube_t& cube, unsigned offset )\n {\n gate::control_container controls;\n for ( unsigned i = 0u; i < cf.num_vars(); ++i )\n {\n if ( cube.second[3u * i + offset] )\n {\n controls += make_var( i, cube.first[3u * i + offset] );\n }\n }\n\n insert_toffoli( circ, insert_position, controls, _var );\n insert_position++;\n }\n\n void create_toffoli_gates_with_exorcism(const BDD& gate, unsigned var, unsigned offset, bool add_gates_to_circuit = true)\n {\n if (gate == cf.manager().bddZero()) return;\n\n if ( genesop )\n {\n std::ofstream esopout;\n esopout.open( boost::str( boost::format( \"/tmp/%s_%d_%d.pla\" ) % name % var % offset ) );\n esopout << \".i \" << cf.num_vars() << std::endl;\n esopout << \".o \" << 1 << std::endl;\n\n int *cube;\n CUDD_VALUE_TYPE value;\n DdGen *gen;\n\n Cudd_ForeachCube(gate.manager(), gate.getNode(), gen, cube, value)\n {\n char v;\n\n for (unsigned i = 0u; i < cf.num_vars(); ++i)\n {\n v = cube[3u * i + offset];\n if (v != 2)\n {\n esopout << ((v == 0) ? \"0\" : \"1\");\n }\n else\n {\n esopout << \"-\";\n }\n }\n\n esopout << \" 1\" << std::endl;\n }\n\n esopout << \".e\" << std::endl;\n esopout.close();\n }\n\n if ( create_gates )\n {\n if ( add_gates_to_circuit )\n {\n esopmin.settings()->set( \"on_cube\", cube_function_t( [this, &offset]( const cube_t& c ) { add_toffoli_gate( c, offset ); } ) );\n }\n else\n {\n esopmin.settings()->set( \"on_cube\", cube_function_t( [this, &offset]( const cube_t& c ) {} ) );\n }\n esopmin.settings()->set( \"verify\", false );\n esopmin( gate.manager(), gate.getNode() );\n\n if ( add_gates_to_circuit && offset == 1u )\n {\n insert_position -= esopmin.statistics()->get( \"cube_count\" );\n }\n\n total_toffoli_gates += esopmin.statistics()->get( \"cube_count\" );\n total_control_lines += esopmin.statistics()->get( \"literal_count\" );\n }\n\n /*\n system(\"exorcism /tmp/test.esop\");\n\n // Get number of gates\n total_toffoli_gates += boost::lexical_cast(execute_and_return_output(\"cat /tmp/test.esop | grep -v -e \\\"^[#\\\\.]\\\" | wc -l\"));\n total_control_lines += boost::lexical_cast(execute_and_return_output(\"cat /tmp/test.esop | grep -v -e \\\"^[#\\\\.]\\\" | awk '{print $1}' | tr '\\\\n' ' ' | sed -e \\\"s/[^01]//g\\\" | wc -c\"));\n\n // Get gates\n using boost::format;\n using boost::str;\n\n std::ifstream is;\n is.open(\"/tmp/test.esop\");\n\n std::string line;\n while (std::getline(is, line)) {\n boost::trim(line);\n if (line.empty()) continue;\n\n if (line[0] == '0' || line[0] == '1' || line[0] == '-') {\n std::string negate, vars;\n unsigned c = 0u;\n for (unsigned i = 0u; i < mgr.num_vars(); ++i) {\n if (line[i] == '0') {\n negate += str(format(\"t1 x%d\\n\") % i);\n }\n if (line[i] == '0' || line[i] == '1') {\n vars += str(format(\" x%d\") % i);\n ++c;\n }\n }\n std::string _gate = str(format(\"%st%d%s x%d\\n%s\") % negate % (c + 1u) % vars % _var % negate);\n if (offset == 0u) {\n real_l += _gate;\n } else {\n real_r = _gate + real_r;\n }\n }\n }\n is.close();\n */\n }\n\n void default_synthesis()\n {\n null_stream ns;\n std::ostream null_out( &ns );\n boost::progress_display show_progress( cf.num_vars(), progress ? std::cout : null_out );\n\n for (unsigned var = 0; var < cf.num_vars(); ++var)\n {\n ++show_progress;\n set_var(var);\n\n if ( synthesis_method == ResolveCycles )\n {\n only_left_gate_shortcut();\n resolve_one_cycles();\n resolve_two_cycles();\n resolve_k_cycles();\n\n if ( false /*verbose*/ )\n {\n std::cout << \"Target: \" << _var << std::endl << \" - left control function:\" << std::endl;\n left_f.PrintMinterm();\n std::cout << \" - right control function:\" << std::endl;\n right_f.PrintMinterm();\n }\n\n create_toffoli_gates_with_exorcism(left_f, var, 0u);\n create_toffoli_gates_with_exorcism(right_f, var, 1u);\n }\n else if ( synthesis_method == TranspositionsX )\n {\n //resolve_cycles_with_transpositions( resolve_x );\n }\n else if ( synthesis_method == TranspositionsY )\n {\n //resolve_cycles_with_transpositions( resolve_y );\n }\n }\n }\n\n void heuristic_swap() //Get chi\n {\n std::vector list_lines;\n for (unsigned var = 0; var < cf.num_vars(); ++var)\n {\n list_lines.push_back(var);\n }\n\n BDD lf_c, lr_c;\n\n while (!list_lines.empty())\n {\n unsigned min_cost = UINT_MAX;\n unsigned best_line = 0u;\n\n for (unsigned i = 0u; i < list_lines.size(); ++i)\n {\n BDD oldchi = f; //make a copy of chi\n unsigned old_control_lines = total_control_lines;\n unsigned old_toffoli_gates = total_toffoli_gates;\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] - total_toffoli_gates\" << total_toffoli_gates << std::endl;\n }\n set_var(list_lines[i]);\n\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] set_var(var): \" << _var << std::endl;\n }\n only_left_gate_shortcut();\n resolve_one_cycles();\n resolve_two_cycles();\n resolve_k_cycles();\n\n if ( false /*verbose*/ )\n {\n std::cout << \"Target: \" << _var << std::endl << \" - left control function:\" << std::endl;\n left_f.PrintMinterm();\n std::cout << \"[I] - right control function:\" << std::endl;\n right_f.PrintMinterm();\n }\n\n create_toffoli_gates_with_exorcism( left_f, list_lines[i], 0u, false );\n create_toffoli_gates_with_exorcism( right_f, list_lines[i], 1u, false );\n\n\n // Determine cost and save in new_cost\n unsigned new_cost = total_toffoli_gates - old_toffoli_gates;\n\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] h1: Lines: \" << cf.num_vars() << std::endl;\n std::cout << \"[I] h1: Gates: \" << new_cost << std::endl;\n std::cout << \"[I] Controls: \" << total_control_lines << std::endl;\n }\n\n if (new_cost < min_cost)\n {\n best_line = list_lines[i];\n min_cost = new_cost;\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] Min cost: \" << min_cost << std::endl;\n }\n }\n\n f = oldchi;\n total_toffoli_gates = old_toffoli_gates;\n total_control_lines = old_control_lines;\n }\n\n set_var(best_line);\n // Synthesis with best_line\n only_left_gate_shortcut();\n resolve_one_cycles();\n resolve_two_cycles();\n resolve_k_cycles();\n\n create_toffoli_gates_with_exorcism(left_f, best_line, 0u);\n create_toffoli_gates_with_exorcism(right_f, best_line, 1u);\n\n list_lines.erase(std::remove(list_lines.begin(),list_lines.end(),best_line));\n\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] Best Line: \" << best_line << std::endl;\n }\n }\n }\n\n void heuristic_hamming()\n {\n std::vector list_lines;\n for (unsigned var = 0; var < cf.num_vars(); ++var)\n {\n list_lines.push_back(var);\n }\n\n BDD lf_c, lr_c;\n\n while (!list_lines.empty())\n {\n double min_cost = DBL_MAX;\n unsigned best_line = 0u;\n\n for (unsigned i = 0u; i < list_lines.size(); ++i)\n {\n // Determine costs and save in new_cost\n double new_cost = cf.cofactor(f, list_lines[i], false, true).CountMinterm(2 * cf.num_vars());\n\n\n if (new_cost < min_cost)\n {\n best_line = list_lines[i];\n min_cost = new_cost;\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] Min cost: \" << min_cost << std::endl;\n }\n }\n }\n\n set_var(best_line);\n // Synthesis with best_line\n only_left_gate_shortcut();\n resolve_one_cycles();\n resolve_two_cycles();\n resolve_k_cycles();\n\n create_toffoli_gates_with_exorcism(left_f, best_line, 0u);\n create_toffoli_gates_with_exorcism(right_f, best_line, 1u);\n\n list_lines.erase(std::remove(list_lines.begin(),list_lines.end(),best_line));\n\n if ( false /*verbose*/ )\n {\n std::cout << \"[I] Best Line: \" << best_line << std::endl;\n }\n }\n }\n\n const rcbdd& cf;\n circuit& circ;\n\n bool verbose;\n bool progress;\n std::string name;\n bool genesop;\n dd_based_esop_optimization_func esopmin;\n bool create_gates;\n bool smart_pickcube;\n SynthesisMethod synthesis_method;\n\n BDD f;\n BDD left_f, right_f;\n unsigned _var;\n unsigned insert_position;\n BDD n, pp, np, p;\n BDD nx, ppx, npx, px;\n BDD ny, ppy, npy, py;\n unsigned total_control_lines = 0u, total_toffoli_gates = 0u;\n unsigned long long access = 0ull;\n std::vector node_count;\n};\n\nbool rcbdd_synthesis( circuit& circ, const rcbdd& cf, properties::ptr settings, properties::ptr statistics )\n{\n /* Settings */\n auto verbose = get( settings, \"verbose\", false );\n auto progress = get( settings, \"progress\", false );\n auto name = get( settings, \"name\", std::string( \"test\" ) );\n auto genesop = get( settings, \"genesop\", false );\n auto esopmin = get( settings, \"esopmin\", dd_based_esop_optimization_func() );\n auto create_gates = get( settings, \"create_gates\", true );\n /* 0: default, 1: swap, 2: hamming */\n auto mode = get( settings, \"mode\", 0u );\n auto synthesis_method = get( settings, \"synthesis_method\", ResolveCycles );\n auto smart_pickcube = get( settings, \"smart_pickcube\", true );\n\n /* Timing */\n properties_timer t( statistics );\n\n rcbdd_synthesis_manager mgr( cf, circ );\n mgr.verbose = verbose;\n mgr.progress = progress;\n mgr.name = name;\n mgr.genesop = genesop;\n mgr.esopmin = esopmin;\n mgr.create_gates = create_gates;\n mgr.synthesis_method = synthesis_method;\n mgr.smart_pickcube = smart_pickcube;\n switch ( mode )\n {\n case 1u:\n mgr.heuristic_swap();\n break;\n case 2u:\n mgr.heuristic_hamming();\n break;\n default:\n mgr.default_synthesis();\n };\n\n if ( statistics )\n {\n statistics->set( \"access\", mgr.access );\n statistics->set( \"node_count\", mgr.node_count );\n }\n\n return true;\n}\n\n}\n\n// Local Variables:\n// c-basic-offset: 2\n// eval: (c-set-offset 'substatement-open 0)\n// eval: (c-set-offset 'innamespace 0)\n// End:\n", "meta": {"hexsha": "0913429dd0cc68e705efe55ac0184ac3d30de586", "size": 23955, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "addons/cirkit-addon-reversible/src/reversible/synthesis/rcbdd_synthesis.cpp", "max_stars_repo_name": "eletesta/cirkit", "max_stars_repo_head_hexsha": "6d0939798ea25cecf92306ce796be154139b94f5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "addons/cirkit-addon-reversible/src/reversible/synthesis/rcbdd_synthesis.cpp", "max_issues_repo_name": "eletesta/cirkit", "max_issues_repo_head_hexsha": "6d0939798ea25cecf92306ce796be154139b94f5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "addons/cirkit-addon-reversible/src/reversible/synthesis/rcbdd_synthesis.cpp", "max_forks_repo_name": "eletesta/cirkit", "max_forks_repo_head_hexsha": "6d0939798ea25cecf92306ce796be154139b94f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9848130841, "max_line_length": 207, "alphanum_fraction": 0.5536213734, "num_tokens": 6730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746213017459, "lm_q2_score": 0.4726834766204328, "lm_q1q2_score": 0.2976840574842257}} {"text": "/*\n * Copyright (c) 2008-2009 Radu Bogdan Rusu \n *\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n *\n * $Id: sac_model_sphere.cpp 21050 2009-08-07 21:24:30Z jfaustwg $\n *\n */\n\n/** \\author Radu Bogdan Rusu */\n\n#include \n#include \n#include \n\n#include \n\nnamespace sample_consensus\n{\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Get 4 random points (3 non-collinear) as data samples and return them as point indices.\n * \\param iterations the internal number of iterations used by SAC methods\n * \\param samples the resultant model samples\n * \\note assumes unique points!\n * \\note Two different points could be enough in theory, to infere some sort of a center and a radius,\n * but in practice, we might end up with a lot of points which are just 'close' to one another.\n * Therefore we have two options:\n * a) use normal information (good but I wouldn't rely on it in extremely noisy point clouds, no matter what)\n * b) get two more points and uniquely identify a sphere in space (3 unique points define a circle)\n */\n void\n SACModelSphere::getSamples (int &iterations, std::vector &samples)\n {\n samples.resize (4);\n double trand = indices_.size () / (RAND_MAX + 1.0);\n\n // Get a random number between 1 and max_indices\n int idx = (int)(rand () * trand);\n // Get the index\n samples[0] = indices_.at (idx);\n\n // Get a second point which is different than the first\n do\n {\n idx = (int)(rand () * trand);\n samples[1] = indices_.at (idx);\n iterations++;\n } while (samples[1] == samples[0]);\n iterations--;\n\n double Dx1, Dy1, Dz1, Dx2, Dy2, Dz2, Dy1Dy2;\n // Compute the segment values (in 3d) between XY\n Dx1 = cloud_->points[samples[1]].x - cloud_->points[samples[0]].x;\n Dy1 = cloud_->points[samples[1]].y - cloud_->points[samples[0]].y;\n Dz1 = cloud_->points[samples[1]].z - cloud_->points[samples[0]].z;\n\n int iter = 0;\n do\n {\n // Get the third point, different from the first two\n do\n {\n idx = (int)(rand () * trand);\n samples[2] = indices_.at (idx);\n iterations++;\n } while ( (samples[2] == samples[1]) || (samples[2] == samples[0]) );\n iterations--;\n\n // Compute the segment values (in 3d) between XZ\n Dx2 = cloud_->points[samples[2]].x - cloud_->points[samples[0]].x;\n Dy2 = cloud_->points[samples[2]].y - cloud_->points[samples[0]].y;\n Dz2 = cloud_->points[samples[2]].z - cloud_->points[samples[0]].z;\n\n Dy1Dy2 = Dy1 / Dy2;\n iter++;\n\n if (iter > MAX_ITERATIONS_COLLINEAR )\n {\n ROS_WARN (\"[SACModelSphere::getSamples] WARNING: Could not select 3 non collinear points in %d iterations!\", MAX_ITERATIONS_COLLINEAR);\n break;\n }\n iterations++;\n }\n // Use Zoli's method for collinearity check\n while (((Dx1 / Dx2) == Dy1Dy2) && (Dy1Dy2 == (Dz1 / Dz2)));\n iterations--;\n\n // Need to improve this: we need 4 points, 3 non-collinear always, and the 4th should not be in the same plane as the other 3\n // otherwise we can encounter degenerate cases\n do\n {\n samples[3] = (int)(rand () * trand);\n iterations++;\n } while ( (samples[3] == samples[2]) || (samples[3] == samples[1]) || (samples[3] == samples[0]) );\n iterations--;\n\n return;\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Select all the points which respect the given model coefficients as inliers.\n * \\param model_coefficients the coefficients of a sphere model that we need to compute distances to\n * \\param threshold a maximum admissible distance threshold for determining the inliers from the outliers\n * \\param inliers the resultant model inliers\n * \\note: To get the refined inliers of a model, use:\n * ANNpoint refined_coeff = refitModel (...); selectWithinDistance (refined_coeff, threshold);\n */\n void\n SACModelSphere::selectWithinDistance (const std::vector &model_coefficients, double threshold, std::vector &inliers)\n {\n int nr_p = 0;\n inliers.resize (indices_.size ());\n\n // Iterate through the 3d points and calculate the distances from them to the sphere\n for (unsigned int i = 0; i < indices_.size (); i++)\n {\n // Calculate the distance from the point to the sphere as the difference between\n //dist(point,sphere_origin) and sphere_radius\n if (fabs (sqrt (\n ( cloud_->points.at (indices_[i]).x - model_coefficients.at (0) ) *\n ( cloud_->points.at (indices_[i]).x - model_coefficients.at (0) ) +\n\n ( cloud_->points.at (indices_[i]).y - model_coefficients.at (1) ) *\n ( cloud_->points.at (indices_[i]).y - model_coefficients.at (1) ) +\n\n ( cloud_->points.at (indices_[i]).z - model_coefficients.at (2) ) *\n ( cloud_->points.at (indices_[i]).z - model_coefficients.at (2) )\n ) - model_coefficients.at (3)) < threshold)\n {\n // Returns the indices of the points whose distances are smaller than the threshold\n inliers[nr_p] = indices_[i];\n nr_p++;\n }\n }\n inliers.resize (nr_p);\n return;\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Compute all distances from the cloud data to a given sphere model.\n * \\param model_coefficients the coefficients of a sphere model that we need to compute distances to\n * \\param distances the resultant estimated distances\n */\n void\n SACModelSphere::getDistancesToModel (const std::vector &model_coefficients, std::vector &distances)\n {\n distances.resize (indices_.size ());\n\n // Iterate through the 3d points and calculate the distances from them to the sphere\n for (unsigned int i = 0; i < indices_.size (); i++)\n // Calculate the distance from the point to the sphere as the difference between\n //dist(point,sphere_origin) and sphere_radius\n distances[i] = fabs (sqrt (\n ( cloud_->points.at (indices_[i]).x - model_coefficients.at (0) ) *\n ( cloud_->points.at (indices_[i]).x - model_coefficients.at (0) ) +\n\n ( cloud_->points.at (indices_[i]).y - model_coefficients.at (1) ) *\n ( cloud_->points.at (indices_[i]).y - model_coefficients.at (1) ) +\n\n ( cloud_->points.at (indices_[i]).z - model_coefficients.at (2) ) *\n ( cloud_->points.at (indices_[i]).z - model_coefficients.at (2) )\n ) - model_coefficients.at (3));\n return;\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Create a new point cloud with inliers projected onto the sphere model.\n * \\param inliers the data inliers that we want to project on the sphere model\n * \\param model_coefficients the coefficients of a sphere model\n * \\param projected_points the resultant projected points\n * \\todo implement this.\n */\n void\n SACModelSphere::projectPoints (const std::vector &inliers, const std::vector &model_coefficients,\n sensor_msgs::PointCloud &projected_points)\n {\n std::cerr << \"[SACModelSphere::projecPoints] Not implemented yet.\" << std::endl;\n projected_points = *cloud_;\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Project inliers (in place) onto the given sphere model.\n * \\param inliers the data inliers that we want to project on the sphere model\n * \\param model_coefficients the coefficients of a sphere model\n * \\todo implement this.\n */\n void\n SACModelSphere::projectPointsInPlace (const std::vector &inliers, const std::vector &model_coefficients)\n {\n std::cerr << \"[SACModelSphere::projecPointsInPlace] Not implemented yet.\" << std::endl;\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Check whether the given index samples can form a valid sphere model, compute the model coefficients from\n * these samples and store them internally in model_coefficients_. The sphere coefficients are: x, y, z, R.\n * \\param samples the point indices found as possible good candidates for creating a valid model\n */\n bool\n SACModelSphere::computeModelCoefficients (const std::vector &samples)\n {\n model_coefficients_.resize (4);\n\n Eigen::Matrix4d temp;\n for (int i = 0; i < 4; i++)\n {\n temp (i, 0) = cloud_->points.at (samples.at (i)).x;\n temp (i, 1) = cloud_->points.at (samples.at (i)).y;\n temp (i, 2) = cloud_->points.at (samples.at (i)).z;\n temp (i, 3) = 1;\n }\n double m11 = temp.determinant ();\n if (m11 == 0)\n return (false); // the points don't define a sphere!\n\n for (int i = 0; i < 4; i++)\n temp (i, 0) = (cloud_->points.at (samples.at (i)).x) * (cloud_->points.at (samples.at (i)).x) +\n (cloud_->points.at (samples.at (i)).y) * (cloud_->points.at (samples.at (i)).y) +\n (cloud_->points.at (samples.at (i)).z) * (cloud_->points.at (samples.at (i)).z);\n double m12 = temp.determinant ();\n\n for (int i = 0; i < 4; i++)\n {\n temp (i, 1) = temp (i, 0);\n temp (i, 0) = cloud_->points.at (samples.at (i)).x;\n }\n double m13 = temp.determinant ();\n\n for (int i = 0; i < 4; i++)\n {\n temp (i, 2) = temp (i, 1);\n temp (i, 1) = cloud_->points.at (samples.at (i)).y;\n }\n double m14 = temp.determinant ();\n\n for (int i = 0; i < 4; i++)\n {\n temp (i, 0) = temp (i, 2);\n temp (i, 1) = cloud_->points.at (samples.at (i)).x;\n temp (i, 2) = cloud_->points.at (samples.at (i)).y;\n temp (i, 3) = cloud_->points.at (samples.at (i)).z;\n }\n double m15 = temp.determinant ();\n\n // Center (x , y, z)\n model_coefficients_[0] = 0.5 * m12 / m11;\n model_coefficients_[1] = 0.5 * m13 / m11;\n model_coefficients_[2] = 0.5 * m14 / m11;\n // Radius\n model_coefficients_[3] = sqrt (\n model_coefficients_[0] * model_coefficients_[0] +\n model_coefficients_[1] * model_coefficients_[1] +\n model_coefficients_[2] * model_coefficients_[2] - m15 / m11);\n\n return (true);\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Recompute the sphere coefficients using the given inlier set and return them to the user.\n * @note: these are the coefficients of the sphere model after refinement (eg. after SVD)\n * \\param inliers the data inliers found as supporting the model\n * \\param refit_coefficients the resultant recomputed coefficients after non-linear optimization\n */\n void\n SACModelSphere::refitModel (const std::vector &inliers, std::vector &refit_coefficients)\n {\n if (inliers.size () == 0)\n {\n ROS_ERROR (\"[SACModelSphere::RefitModel] Cannot re-fit 0 inliers!\");\n refit_coefficients = model_coefficients_;\n return;\n }\n if (model_coefficients_.size () == 0)\n {\n ROS_WARN (\"[SACModelSphere::RefitModel] Initial model coefficients have not been estimated yet - proceeding without an initial solution!\");\n best_inliers_ = indices_;\n }\n\n tmp_inliers_ = &inliers;\n \n int m = inliers.size ();\n\n double *fvec = new double[m];\n\n int n = 4; // 4 unknowns\n int iwa[n];\n\n int lwa = m * n + 5 * n + m;\n double *wa = new double[lwa];\n\n // Set the initial solution\n double x[4] = {0.0, 0.0, 0.0, 0.0};\n if ((int)model_coefficients_.size () == n)\n for (int d = 0; d < n; d++)\n x[d] = model_coefficients_.at (d);\n\n // Set tol to the square root of the machine. Unless high solutions are required, these are the recommended settings.\n double tol = sqrt (dpmpar (1));\n\n // Optimize using forward-difference approximation LM\n int info = lmdif1 (&sample_consensus::SACModelSphere::functionToOptimize, this, m, n, x, fvec, tol, iwa, wa, lwa);\n\n // Compute the L2 norm of the residuals\n ROS_DEBUG (\"LM solver finished with exit code %i, having a residual norm of %g. \\nInitial solution: %g %g %g %g \\nFinal solution: %g %g %g %g\",\n info, enorm (m, fvec), model_coefficients_.at (0), model_coefficients_.at (1), model_coefficients_.at (2), model_coefficients_.at (3),\n x[0], x[1], x[2], x[3]);\n\n refit_coefficients.resize (n);\n for (int d = 0; d < n; d++)\n refit_coefficients[d] = x[d];\n\n free (wa); free (fvec);\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////(\n /** \\brief Cost function to be minimized\n * \\param p a pointer to our data structure array\n * \\param m the number of functions\n * \\param n the number of variables\n * \\param x a pointer to the variables array\n * \\param fvec a pointer to the resultant functions evaluations\n * \\param iflag set to -1 inside the function to terminate execution\n */\n int\n SACModelSphere::functionToOptimize (void *p, int m, int n, const double *x, double *fvec, int iflag)\n {\n SACModelSphere *model = (SACModelSphere*)p;\n\n for (int i = 0; i < m; i ++)\n {\n // Compute the difference between the center of the sphere and the datapoint X_i\n double xt = model->cloud_->points[model->tmp_inliers_->at (i)].x - x[0];\n double yt = model->cloud_->points[model->tmp_inliers_->at (i)].y - x[1];\n double zt = model->cloud_->points[model->tmp_inliers_->at (i)].z - x[2];\n\n // g = sqrt ((x-a)^2 + (y-b)^2 + (z-c)^2) - R\n fvec[i] = sqrt (xt * xt + yt * yt + zt * zt) - x[3];\n }\n return (0);\n }\n\n //////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n /** \\brief Verify whether a subset of indices verifies the internal sphere model coefficients.\n * \\param indices the data indices that need to be tested against the sphere model\n * \\param threshold a maximum admissible distance threshold for determining the inliers from the outliers\n */\n bool\n SACModelSphere::doSamplesVerifyModel (const std::set &indices, double threshold)\n {\n for (std::set::iterator it = indices.begin (); it != indices.end (); ++it)\n // Calculate the distance from the point to the sphere as the difference between\n //dist(point,sphere_origin) and sphere_radius\n if (fabs (sqrt (\n ( cloud_->points.at (*it).x - model_coefficients_.at (0) ) *\n ( cloud_->points.at (*it).x - model_coefficients_.at (0) ) +\n\n ( cloud_->points.at (*it).y - model_coefficients_.at (1) ) *\n ( cloud_->points.at (*it).y - model_coefficients_.at (1) ) +\n\n ( cloud_->points.at (*it).z - model_coefficients_.at (2) ) *\n ( cloud_->points.at (*it).z - model_coefficients_.at (2) )\n ) - model_coefficients_.at (3)) > threshold)\n return (false);\n\n return (true);\n }\n}\n", "meta": {"hexsha": "a6a2845e0df27006d1351509668831f1987fbe0c", "size": 17029, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "11_learning_materials/stanford_self_driving_car/perception/point_cloud_mapping/src/sample_consensus/sac_model_sphere.cpp", "max_stars_repo_name": "EatAllBugs/autonomous_learning", "max_stars_repo_head_hexsha": "02ff7b0fa7b131a2f2203505ef5cc7e43b40bc47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2021-09-01T14:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-21T08:49:57.000Z", "max_issues_repo_path": "11_learning_materials/stanford_self_driving_car/perception/point_cloud_mapping/src/sample_consensus/sac_model_sphere.cpp", "max_issues_repo_name": "yinflight/autonomous_learning", "max_issues_repo_head_hexsha": "02ff7b0fa7b131a2f2203505ef5cc7e43b40bc47", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "11_learning_materials/stanford_self_driving_car/perception/point_cloud_mapping/src/sample_consensus/sac_model_sphere.cpp", "max_forks_repo_name": "yinflight/autonomous_learning", "max_forks_repo_head_hexsha": "02ff7b0fa7b131a2f2203505ef5cc7e43b40bc47", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2021-10-10T00:58:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-23T13:16:09.000Z", "avg_line_length": 43.8891752577, "max_line_length": 149, "alphanum_fraction": 0.5851782254, "num_tokens": 4284, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6297746074044134, "lm_q2_score": 0.47268347662043286, "lm_q1q2_score": 0.2976840509151863}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n//#include \n\nenum KernelType {CubicSpline = 0, WendlandC2 = 1, WendlandC4 = 2};\n\n#include \"particle_simulator.hpp\"\n#include \"hdr_time.hpp\"\n#include \"hdr_run.hpp\"\n#ifdef USE_INTRINSICS\n#include \"vector_x86.hpp\"\n#endif\n#include \"hdr_dimension.hpp\"\n#include \"hdr_kernel.hpp\"\n#include \"hdr_sph.hpp\"\n#include \"hdr_hgas.hpp\"\n#include \"hdr_bhns.hpp\"\n\nclass SPHAnalysis : public HelmholtzGas {\npublic:\n SPHAnalysis() {\n this->id = 0;\n this->istar = 0;\n this->mass = 0.;\n this->pos = 0.;\n this->vel = 0.;\n this->uene = 0.;\n this->alph = 0.;\n this->alphu = 0.;\n this->ksr = 0.;\n for(PS::S32 k = 0; k < NR::NumberOfNucleon; k++) {\n this->cmps[k] = 0.;\n } \n }\n\n void readAscii(FILE * fp) {\n fscanf(fp, \"%lld%lld%lf\", &this->id, &this->istar, &this->mass); // 3\n fscanf(fp, \"%lf%lf%lf\", &this->pos[0], &this->pos[1], &this->pos[2]); // 6\n fscanf(fp, \"%lf%lf%lf\", &this->vel[0], &this->vel[1], &this->vel[2]); // 9\n fscanf(fp, \"%lf%lf%lf\", &this->acc[0], &this->acc[1], &this->acc[2]); // 12\n fscanf(fp, \"%lf%lf%lf\", &this->uene, &this->alph, &this->alphu); // 15\n fscanf(fp, \"%lf%lf%6d\", &this->dens, &this->ksr, &this->np); // 18\n fscanf(fp, \"%lf%lf%lf\", &this->vsnd, &this->pres, &this->temp); // 21\n fscanf(fp, \"%lf%lf%lf\", &this->divv, &this->rotv, &this->bswt); // 24\n fscanf(fp, \"%lf%lf%lf\", &this->pot, &this->abar, &this->zbar); // 27\n fscanf(fp, \"%lf\", &this->enuc); // 28\n fscanf(fp, \"%lf%lf%lf\", &this->vsmx, &this->udot, &this->dnuc); // 31\n for(PS::S32 k = 0; k < NuclearReaction::NumberOfNucleon; k++) { // 32 -- 44\n fscanf(fp, \"%lf\", &this->cmps[k]);\n }\n fscanf(fp, \"%lf\", &this->pot3);\n fscanf(fp, \"%lf%lf%lf\", &this->tempmax[0], &this->tempmax[1], &this->tempmax[2]);\n fscanf(fp, \"%lf\", &this->entr);\n }\n\n};\n\nnamespace SphericalHarmonics {\n PS::F64 CoefficientY00 = 0.5 * sqrt(1.0 / M_PI);\n PS::F64 CoefficientY10 = 0.5 * sqrt(3.0 / M_PI);\n PS::F64 CoefficientY11 = 0.5 * sqrt(1.5 / M_PI);\n PS::F64 CoefficientY20 = sqrt( 5. / (16. * M_PI));\n PS::F64 CoefficientY22 = sqrt(15. / (32. * M_PI));\n\n bool FirstTime = true;\n PS::F64 MinimumRadius = 1e+08;\n PS::F64 MaximumRadius = 1e+11;\n PS::S64 NumberOfBinPerDex = 10;\n\n PS::S64 NumberOfBin = 0;\n const PS::S64 MaximumNumberOfBin = 64;\n static PS::F64 m00re[MaximumNumberOfBin];\n static PS::F64 m10re[MaximumNumberOfBin];\n static PS::F64 m11re[MaximumNumberOfBin];\n static PS::F64 m11im[MaximumNumberOfBin];\n static PS::F64 m20re[MaximumNumberOfBin];\n static PS::F64 m22re[MaximumNumberOfBin];\n static PS::F64 m22im[MaximumNumberOfBin];\n static PS::S64 nptcl[MaximumNumberOfBin];\n static PS::F64 m00re_g[MaximumNumberOfBin];\n static PS::F64 m10re_g[MaximumNumberOfBin];\n static PS::F64 m11re_g[MaximumNumberOfBin];\n static PS::F64 m11im_g[MaximumNumberOfBin];\n static PS::F64 m20re_g[MaximumNumberOfBin];\n static PS::F64 m22re_g[MaximumNumberOfBin];\n static PS::F64 m22im_g[MaximumNumberOfBin];\n static PS::S64 nptcl_g[MaximumNumberOfBin];\n\n void initialize() {\n FirstTime = false;\n PS::F64 temp = log10(MaximumRadius / MinimumRadius) * NumberOfBinPerDex;\n NumberOfBin = (temp - (PS::S64)temp == 0.) ? (PS::S64)temp : (PS::S64)(temp + 1.);\n assert(NumberOfBin <= MaximumNumberOfBin);\n for(PS::S64 i = 0; i < NumberOfBin; i++) {\n m00re[i] = 0.;\n m10re[i] = 0.;\n m11re[i] = 0.;\n m11im[i] = 0.;\n m20re[i] = 0.;\n m22re[i] = 0.;\n m22im[i] = 0.;\n nptcl[i] = 0;\n m00re_g[i] = 0.;\n m10re_g[i] = 0.;\n m11re_g[i] = 0.;\n m11im_g[i] = 0.;\n nptcl_g[i] = 0.;\n }\n }\n\n void reinitialize() {\n for(PS::S64 i = 0; i < NumberOfBin; i++) {\n m00re[i] = 0.;\n m10re[i] = 0.;\n m11re[i] = 0.;\n m11im[i] = 0.;\n m20re[i] = 0.;\n m22re[i] = 0.;\n m22im[i] = 0.;\n nptcl[i] = 0;\n m00re_g[i] = 0.;\n m10re_g[i] = 0.;\n m11re_g[i] = 0.;\n m11im_g[i] = 0.;\n nptcl_g[i] = 0.;\n }\n }\n\n template \n inline void addParticle(Tsph & isph) {\n PS::F64 r2 = isph.pos * isph.pos;\n if(r2 >= MaximumRadius * MaximumRadius) {\n return;\n }\n PS::F64 r1 = sqrt(r2);\n PS::S64 ibin = PS::S64(log10(r1 / MinimumRadius) * NumberOfBinPerDex);\n assert(ibin < NumberOfBin);\n\n PS::F64 cr = sqrt(isph.pos[0] * isph.pos[0] + isph.pos[1] * isph.pos[1]);\n PS::F64 prinv = 1. / r1;\n PS::F64 crinv = 1. / cr;\n PS::F64 costheta = isph.pos[2] * prinv;\n PS::F64 sintheta = cr * prinv;\n PS::F64 cosphi = isph.pos[0] * crinv;\n PS::F64 sinphi = isph.pos[1] * crinv;\n\n PS::F64 costheta_sq = costheta * costheta;\n PS::F64 sintheta_sq = sintheta * sintheta;\n PS::F64 cosphi_2times = cosphi * cosphi - sinphi * sinphi;\n PS::F64 sinphi_2times = 2. * sinphi * cosphi;\n\n m00re[ibin] += isph.mass * CoefficientY00;\n m10re[ibin] += isph.mass * CoefficientY10 * costheta;\n m11re[ibin] += isph.mass * CoefficientY11 * sintheta * cosphi;\n m11im[ibin] += isph.mass * CoefficientY11 * sintheta * sinphi;\n m20re[ibin] += isph.mass * CoefficientY20 * (3. * costheta_sq - 1.);\n m22re[ibin] += isph.mass * CoefficientY22 * sintheta_sq * cosphi_2times;\n m22im[ibin] += isph.mass * CoefficientY22 * sintheta_sq * sinphi_2times;\n nptcl[ibin] += 1;\n }\n\n void reduce() {\n PS::S64 ierr = 0;\n ierr = MPI_Allreduce(m00re, m00re_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(m10re, m10re_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(m11re, m11re_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(m11im, m11im_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(m20re, m20re_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(m22re, m22re_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(m22im, m22im_g, NumberOfBin, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);\n ierr = MPI_Allreduce(nptcl, nptcl_g, NumberOfBin, MPI_LONG_LONG, MPI_SUM, MPI_COMM_WORLD);\n }\n\n void output(FILE * fp) {\n for(PS::S64 i = 0; i < NumberOfBin; i++) {\n PS::F64 r = (i == 0) ? (0.5 * MinimumRadius)\n : (MinimumRadius * pow(10., (i - 0.5) / NumberOfBinPerDex));\n fprintf(fp, \"%+e %+e %+e %+e %+e %+e %+e %+e %8d\\n\",\n r,\n m00re_g[i], m10re_g[i], m11re_g[i], m11im_g[i],\n m20re_g[i], m22re_g[i], m22im_g[i],\n nptcl_g[i]);\n }\n }\n\n};\n\ntemplate \nvoid calcDensityCenter(Tsph & sph,\n PS::F64vec & xdens_g,\n PS::F64vec & vdens_g,\n PS::F64vec & adens_g) {\n PS::F64 tdens = 0.;\n PS::F64vec xdens = 0.;\n PS::F64vec vdens = 0.;\n PS::F64vec adens = 0.;\n\n for(PS::S64 i = 0; i < sph.getNumberOfParticleLocal(); i++) {\n if(sph[i].istar == 1) {\n continue;\n }\n tdens += sph[i].dens;\n xdens += sph[i].dens * sph[i].pos;\n vdens += sph[i].dens * sph[i].vel;\n adens += sph[i].dens * sph[i].acc;\n }\n\n PS::F64 tdens_g = PS::Comm::getSum(tdens);\n xdens_g = PS::Comm::getSum(xdens);\n vdens_g = PS::Comm::getSum(vdens);\n adens_g = PS::Comm::getSum(adens);\n\n xdens_g = xdens_g / tdens_g;\n vdens_g = vdens_g / tdens_g;\n adens_g = adens_g / tdens_g;\n\n return;\n}\n\ntemplate \nvoid expandInSphericalHarmonics(char * ofile,\n Tsph & sph) {\n PS::F64vec xdens = 0.;\n PS::F64vec vdens = 0.;\n PS::F64vec adens = 0.;\n calcDensityCenter(sph, xdens, vdens, adens);\n for(PS::S64 i = 0; i < sph.getNumberOfParticleLocal(); i++) {\n sph[i].pos -= xdens;\n sph[i].vel -= vdens;\n sph[i].acc -= adens;\n }\n\n if(SphericalHarmonics::FirstTime) {\n SphericalHarmonics::initialize();\n } else {\n SphericalHarmonics::reinitialize();\n }\n\n for(PS::S64 i = 0; i < sph.getNumberOfParticleLocal(); i++) {\n SphericalHarmonics::addParticle(sph[i]);\n }\n\n SphericalHarmonics::reduce();\n\n if(PS::Comm::getRank() == 0) {\n FILE * fp = fopen(ofile, \"w\");\n SphericalHarmonics::output(fp);\n fclose(fp);\n }\n\n}\n\nint main(int argc, char ** argv) {\n PS::Initialize(argc, argv);\n\n PS::ParticleSystem sph;\n sph.initialize();\n sph.createParticle(0);\n sph.setNumberOfParticleLocal(0);\n\n char idir[1024], odir[1024];\n PS::S64 ibgn, iend, dsnp;\n FILE * fp = fopen(argv[1], \"r\");\n fscanf(fp, \"%s\", idir);\n fscanf(fp, \"%s\", odir);\n fscanf(fp, \"%lld%lld%lld\", &ibgn, &iend, &dsnp);\n fclose(fp);\n\n for(PS::S64 itime = ibgn; itime <= iend; itime += dsnp) { \n char tfile[1024];\n FILE *fp = NULL;\n PS::S64 tdir = 0;\n for(PS::S64 iidir = 0; iidir < 100; iidir++) {\n sprintf(tfile, \"%s/t%02d/sph_t%04d_p%06d_i%06d.dat\", idir, iidir, itime,\n PS::Comm::getNumberOfProc(), 0);\n fp = fopen(tfile, \"r\");\n if(fp != NULL) {\n tdir = iidir;\n break;\n }\n }\n if(fp == NULL) {\n if(PS::Comm::getRank() == 0) {\n fprintf(stderr, \"Not found %s\\n\", tfile);\n }\n continue;\n }\n fclose(fp);\n\n char sfile[1024];\n sprintf(sfile, \"%s/t%02d/sph_t%04d\", idir, tdir, itime);\n sph.readParticleAscii(sfile, \"%s_p%06d_i%06d.dat\");\n\n char ofile[1024];\n sprintf(ofile, \"%s/harmonics_t%04d.dat\", odir, itime);\n expandInSphericalHarmonics(ofile, sph);\n }\n\n PS::Finalize();\n\n return 0;\n}\n", "meta": {"hexsha": "9a6d6b29284909262935349252a09e187b81b26a", "size": 10514, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "code/expandInSphericalHarmonics/main.cpp", "max_stars_repo_name": "atrtnkw/sph", "max_stars_repo_head_hexsha": "c6bb3d7fd18f57c51fe60197706741e5a26e6ce4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-11T00:43:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-11T13:41:50.000Z", "max_issues_repo_path": "code/expandInSphericalHarmonics/main.cpp", "max_issues_repo_name": "atrtnkw/sph", "max_issues_repo_head_hexsha": "c6bb3d7fd18f57c51fe60197706741e5a26e6ce4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/expandInSphericalHarmonics/main.cpp", "max_forks_repo_name": "atrtnkw/sph", "max_forks_repo_head_hexsha": "c6bb3d7fd18f57c51fe60197706741e5a26e6ce4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-01-06T14:22:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-06T14:22:25.000Z", "avg_line_length": 34.2475570033, "max_line_length": 98, "alphanum_fraction": 0.5348107286, "num_tokens": 3504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.661922862511608, "lm_q2_score": 0.4493926344647597, "lm_q1q2_score": 0.29746325899654646}} {"text": "#ifndef _REGEVPROOFS_HPP_\n#define _REGEVPROOFS_HPP_\n/* regevProofs.hpp - Proofs of correct behavior for Regev encryption\n * \n * Copyright (C) 2021, LWE-PVSS\n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject\n * to the following conditions:\n * \n * The above copyright notice and this permission notice shall be included\n * in all copies or substantial portions of the Software.\n * \n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR\n * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n * OTHER DEALINGS IN THE SOFTWARE.\n **/\n#include \n#include \n#include \n#include \n\n#include \n\n#include \"utils.hpp\"\n#include \"regevEnc.hpp\"\n#include \"ternaryMatrix.hpp\"\n#include \"merlin.hpp\"\n#include \"pedersen.hpp\"\n#include \"shamir.hpp\"\n#include \"bulletproof.hpp\"\n#include \"utils.hpp\"\n\n//#define DEBUGGING\n\nnamespace REGEVENC {\nusing CRV25519::Point, DLPROOFS::PedersenContext, TOOLS::SharingParams,\n DLPROOFS::MerlinBPctx, DLPROOFS::LinConstraint, DLPROOFS::QuadConstraint;\n// NOTE: REGEVENC::Scalar is not the same as CRV25519::Scalar\n\n\ninline constexpr int PAD_SIZE=4; // add 4 scalars to pad to a specific sum-of-squares\n\n// We break the decryption error vector into subvectors, each with this many scalars\n#if 1 //ifndef DEBUGGING\ninline constexpr int JLDIM = 256; // Target dimension of Johnson–Lindenstrauss\ninline constexpr int SQRT_JL =16;\ninline constexpr int LINYDIM=128; // Target dimension in approximate l-infty proofs\n#else\ninline constexpr int JLDIM = 16;\ninline constexpr int SQRT_JL =4;\ninline constexpr int LINYDIM =8;\n#endif\n\n// More functionality for a Merlin-context wrapper\nstruct MerlinRegev: public MerlinBPctx {\n MerlinRegev() = default;\n explicit MerlinRegev(const merlin_transcript& m): MerlinBPctx(m) {}\n explicit MerlinRegev(const std::string& st): MerlinBPctx(st) {}\n\n void processVector(const ALGEBRA::SVector& v,\n unsigned char* label=nullptr, size_t llen=0) {\n if (v.length()==0) return;\n unsigned char buf[ALGEBRA::bytesPerScalar()];\n ALGEBRA::scalarBytes(buf, v[0], sizeof(buf));\n merlin_transcript_commit_bytes(&mctx,label,llen,buf,sizeof(buf));\n for (size_t i=1; i Gs, Hs; // lists of generators\n\n // For most vectors, we have the vector itself (e.g., sk2), the\n // compressed vector (e.g., sk2Comp) and the padding that the prover\n // computes to pad the compressed vector to some pre-determined size\n // (e.g., sk2Pad). The ones without compression and padding are\n // sk1,pt1,pt2,y. For the noise vectors we only need the indexes\n // of the compressed vector and padding, not the original vector\n // (since there is no Pedersen commitment to that vector).\n\n // indexes into the generator list\n int pt1Idx, sk1Idx, dCompHiIdx, dPadHiIdx, dCompLoIdx, dPadLoIdx, // dec\n pt2Idx, rIdx, rCompIdx, rPadIdx, eComp1HiIdx, ePad1HiIdx, eComp1LoIdx,\n ePad1LoIdx, eComp2HiIdx, ePad2HiIdx, eComp2LoIdx, ePad2LoIdx, // enc\n sk2Idx, sk2CompIdx, sk2PadIdx,\n kCompHiIdx, kPadHiIdx, kCompLoIdx, kPadLoIdx, // keygen\n yIdx, wIdx; // smallness proof and aggregation\n\n // Commitments to different variables. The quadratic equations require\n // a double-commitment with respect to both the G and H generators,\n // while the linear constraints only need commitment wrt the Gs.\n\n Point pt1Com, sk1Com, dCompHiCom, dPadHiCom, dCompLoCom, dPadLoCom,// dec\n pt2Com, rCom, rCompCom, rPadCom, eComp1HiCom, ePad1HiCom, eComp1LoCom,\n ePad1LoCom, eComp2HiCom, ePad2HiCom, eComp2LoCom, ePad2LoCom, // enc\n sk2Com, sk2CompCom, sk2PadCom,\n kCompHiCom, kPadHiCom, kCompLoCom, kPadLoCom, // keygen\n yCom, wCom; // smallness proof and aggregation\n\n // A list of all the linear and quadratic constraints\n std::vector linConstr;\n std::vector normConstr;\n\n // pointers into the above vectors of constraints\n static constexpr int dLinIdx=0, // dec\n eLin1Idx=GlobalKey::ell,\n eLin2Idx=2*GlobalKey::ell,\n rLinIdx=3*GlobalKey::ell, // enc\n kLinIdx=4*GlobalKey::ell,\n sk2LinIdx=5*GlobalKey::ell, // keygen,\n smlnsLinIdx=6*GlobalKey::ell, // smallness\n reShrLinIdx=7*GlobalKey::ell; // resharing\n static constexpr int dHiQuadIdx=0, dLoQuadIdx=1, rQuadIdx=2,\n e1HiQuadIdx=3, e1LoQuadIdx=4, e2HiQuadIdx=5, e2LoQuadIdx=6,\n sk2QuadIdx=7, kHiQuadIdx=8, kLoQuadIdx=9;\n\n ALGEBRA::EVector z; // the masked vector z from the proof of smallness\n\n // Set the indexes to their default values\n void setIndexes();\n void computeGenerators();\n\n // Reset when preparing for a new proof at the prover's site\n void prepareForNextProof() {\n std::swap(sk1Idx,sk2Idx);\n sk1Com = sk2Com; // copy commitment to the previous sk wrt the Gs\n\n // zero out all the commitments and constraints\n pt1Com= dCompHiCom= dPadHiCom= dCompLoCom= dPadLoCom= pt2Com= // dec\n rCom= rCompCom= rPadCom= eComp1HiCom= ePad1HiCom= eComp1LoCom=\n ePad1LoCom= eComp2HiCom= ePad2HiCom= eComp2LoCom= ePad2LoCom= // enc\n sk2Com= sk2CompCom= sk2PadCom=\n kCompHiCom= kPadHiCom= kCompLoCom= kPadLoCom= // keygen\n yCom= wCom = Point::identity();\n\n // empty the constraints w/o invalidating the pointers to them\n DLPROOFS::LinConstraint emptyLin;\n for (auto& lc : linConstr) lc = emptyLin;\n DLPROOFS::QuadConstraint emptyQuad;\n for (auto& qc : normConstr) qc = emptyQuad;\n }\n\n VerifierData() = default;\n VerifierData(GlobalKey& gk, PedersenContext& ped, MerlinRegev& mer,\n const SharingParams& sp);\n};\n\n// For each commitment in the VerifierData, the ProverData must hold\n// the corresponding opening: the randomness r and the witness values\nstruct ProverData {\n VerifierData *vd;\n\n // commitment randomness\n CRV25519::Scalar pt1Rnd, sk1Rnd,\n dCompHiRnd, dPadHiRnd, dCompLoRnd, dPadLoRnd, // dec\n pt2Rnd, rRnd, rCompRnd, rPadRnd, eComp1HiRnd, ePad1HiRnd, eComp1LoRnd,\n ePad1LoRnd, eComp2HiRnd, ePad2HiRnd, eComp2LoRnd, ePad2LoRnd, // enc\n sk2Rnd, sk2CompRnd, sk2PadRnd,\n kCompHiRnd, kPadHiRnd, kCompLoRnd, kPadLoRnd, // keygen\n yRnd, wRnd; // smallness proof and aggregation\n\n // The compressed vectors, concatenated\n ALGEBRA::EVector compressed;\n\n // The witnesses for the linear and quadratic constraints\n\n DLPROOFS::PtxtVec linWitness;\n DLPROOFS::PtxtVec quadWitnessG, quadWitnessH;\n\n // Reset when preparing for a new proof at the prover's site\n void prepareForNextProof() {\n vd->prepareForNextProof(); // reset the public data\n sk1Rnd = sk2Rnd; // randomness of commitment to secret key wrt Gs\n }\n\n ProverData() = default; \n ProverData(VerifierData& verData): vd(&verData) {\n compressed.SetLength(10*(JLDIM+PAD_SIZE)/ALGEBRA::scalarsPerElement());\n }\n};\n\n// Proof of decryption. We assume that the ProverData,VerifierData are\n// already initialized, and that ProverData contains sk1 and VerifierData\n// contains a commitment to it.\nvoid proveDecryption(ProverData& pd, \n const ALGEBRA::EMatrix& ctMat, const ALGEBRA::EVector& ctVec,\n const ALGEBRA::SVector& ptxt, const ALGEBRA::EVector& skey,\n const ALGEBRA::EVector& noise);\n\nvoid verifyDecryption(VerifierData& vd, // vd has all the commitments\n const ALGEBRA::EMatrix& ctMat, const ALGEBRA::EVector& ctVec);\n\n// Proof of encryption\nvoid proveEncryption(ProverData& pd,\n const ALGEBRA::EVector& ct1, const ALGEBRA::EVector& ct2, \n const ALGEBRA::SVector& ptxt, const ALGEBRA::EVector& rnd,\n const ALGEBRA::EVector& noise1,const ALGEBRA::EVector& noise2);\n\nvoid verifyEncryption(VerifierData& vd,\n const ALGEBRA::EVector& ct1, const ALGEBRA::EVector& ct2);\n\n// Proof of key-generation. pkNum is index of the pkey in the GlobalKey\nvoid proveKeyGen(ProverData& pd, int pkNum,\n const ALGEBRA::EVector& sk, const ALGEBRA::EVector& noise);\n\nvoid verifyKeyGen(VerifierData& vd, int pkNum);\n\n// Proof of correct re-sharing. It is assumed that pt1, pt2\n// are already initialized in the ps structure\nvoid proveReShare(ProverData& pd, const ALGEBRA::SVector& lagrange,\n const ALGEBRA::SVector& pt1, const ALGEBRA::SVector& pt2);\nvoid verifyReShare(VerifierData& vd, const ALGEBRA::SVector& lagrange);\n // TOOLS::EvalSet from shamir.hpp describes the reconstruction set\n\n// Proof of approximate smallness (of all except the compressed vectors)\nvoid proveSmallness(ProverData& pd);\nvoid verifySmallness(VerifierData& vd);\n\nstruct ReadyToVerify {\n // The linear and quadratic constraints and commitments\n DLPROOFS::LinConstraint linCnstr;\n Point linCom;\n DLPROOFS::QuadConstraint quadCnstr;\n Point quadCom;\n\n // The offset used for the G, H witnesses in the quadratic proof\n DLPROOFS::PtxtVec deltaG, deltaH;\n\n // temporary variables used in aggregating the proofs\n std::vector rVec, uVec;\n DLPROOFS::PtxtVec as, bs;\n\n // Flattened versions of the statements and generators\n std::vector linGs;\n std::vector linStmnt;\n\n std::vector quadGs;\n std::vector quadHs;\n std::vector offstG;\n std::vector offstH;\n\n void aggregateVerifier1(VerifierData& vd);\n void aggregateVerifier2(VerifierData& vd);\n\n void flattenLinVer(VerifierData& vd);\n void flattenQuadVer(VerifierData& vd);\n};\nstruct ReadyToProve : public ReadyToVerify {\n // Randomness used for linCom and quadCom\n CRV25519::Scalar lComRnd, qComRnd;\n\n // Flattened versions of the witnesses\n std::vector linWtns;\n std::vector quadWtnsG, quadWtnsH;\n\n void aggregateProver(ProverData& pd);\n void flattenLinPrv(ProverData& pd);\n void flattenQuadPrv(ProverData& pd);\n};\n\n\n/****** utility functions *******/\n\n// Compute the vector (1,x,x^2,...,x^{len-1})\nvoid powerVector(ALGEBRA::SVector& vec, const ALGEBRA::Scalar& x, int len);\nvoid powerVector(ALGEBRA::EVector& vec, const ALGEBRA::Element& x, int len);\nvoid powerVector(std::vector& vec, const CRV25519::Scalar& x, int len);\n\n// Commit to a slice of the vector\nPoint commit(const ALGEBRA::SVector& v, size_t genIdx,\n const std::vector& Gs, CRV25519::Scalar& r,\n int fromIdx=0, int toIdx=-1);\nPoint commit(const ALGEBRA::EVector& v, size_t genIdx,\n const std::vector& Gs, CRV25519::Scalar& r,\n int fromIdx=0, int toIdx=-1);\n// commit to the same xes wrt both Gs and Hs\nPoint commit2(const ALGEBRA::EVector& v, size_t genIdx,\n const std::vector& Gs, const std::vector& Hs,\n CRV25519::Scalar& r, int fromIdx=0, int toIdx=-1);\n\n// Add to v four integers a,b,c,d such that the result\n// (v | a,b,c,d) has norm exactly equal to the bound\nvoid pad2exactNorm(const ALGEBRA::SVector& v,\n ALGEBRA::SVector& padding, const ALGEBRA::BigInt& bound);\nvoid pad2exactNorm(const ALGEBRA::EVector& v,\n ALGEBRA::EVector& padding, const ALGEBRA::BigInt& bound);\nvoid pad2exactNorm(const ALGEBRA::Element* v, size_t len,\n ALGEBRA::Element* padSpace, const ALGEBRA::BigInt& bound);\n\n// The expand functions below assume that GF(p^ell) is represented\n// modulo X^ell +1.\n\n// Expand a constraint a*x with a in GF(p^ell) to e constrints over scalars,\n// namely store in 'constrs' ell constraints in ell variables, representing\n// the ell-by-ell scalar matrix for multiply-by-a. The variables in these\n// constraints are indexed by idx,idx+1,... For example, the constraints\n// for the 1st row has coeffs: idx->a.freeTerm, idx+1 -> a.coeffOf(X),...\nvoid expandConstraints(LinConstraint* constrs, int idx, const ALGEBRA::Element& a);\n\n// Expand each of the constraints v[i]*x with successive indexes\nvoid expandConstraints(LinConstraint* constrs, int idx,\n const ALGEBRA::EVector& v, int from=0, int to=-1);\n\n// This function is for the case where the secret variables are from Z_p,\n// namely we have the constraint =b over GF(p^ell), but x is over Z_p.\nvoid makeConstraints(LinConstraint* constrs, int idx,\n const ALGEBRA::EVector& v, int from=0, int to=-1);\n\n// This function sets the equalsTo field for the ell constraints\n// corresponding to the ell scalars representing the element e\nvoid setEqsTo(LinConstraint* constrs, const ALGEBRA::Element& e);\n\nbool checkQuadCommit(DLPROOFS::QuadConstraint& c,\n const Point& com, const Point& padCom, const CRV25519::Scalar& rnd,\n const CRV25519::Scalar& padRnd, DLPROOFS::PtxtVec& witness, PedersenContext* ped);\nbool checkLinCommit(DLPROOFS::PtxtVec& pv,\n const Point& com, const CRV25519::Scalar& rnd,\n DLPROOFS::PtxtVec& witness, PedersenContext* ped);\n\n} // end of namespace REGEVENC\n#endif // ifndef _REGEVPROOFS_HPP_\n", "meta": {"hexsha": "ac5c9d36a7b7fe49bae11dc4cc611dfd76bdcff0", "size": 18332, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/regevProofs.hpp", "max_stars_repo_name": "shaih/cpp-lwevss", "max_stars_repo_head_hexsha": "250516eb4270a87383cad40df498da4523242ee8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2022-01-24T21:19:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-27T23:07:39.000Z", "max_issues_repo_path": "include/regevProofs.hpp", "max_issues_repo_name": "shaih/cpp-lwevss", "max_issues_repo_head_hexsha": "250516eb4270a87383cad40df498da4523242ee8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/regevProofs.hpp", "max_forks_repo_name": "shaih/cpp-lwevss", "max_forks_repo_head_hexsha": "250516eb4270a87383cad40df498da4523242ee8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.2358490566, "max_line_length": 91, "alphanum_fraction": 0.6829587606, "num_tokens": 5221, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5813030906443133, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.29746244384854564}} {"text": "// Copyright 2020 the Autoware Foundation\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//    http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// Co-developed by Tier IV, Inc. and Apex.AI, Inc.\n\n#ifndef NDT__UTILS_HPP_\n#define NDT__UTILS_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace autoware\n{\nnamespace localization\n{\nnamespace ndt\n{\n\nstruct PointWithCovariances\n{\n double x;\n double y;\n double z;\n double icov_xx;\n double icov_xy;\n double icov_xz;\n double icov_yy;\n double icov_yz;\n double icov_zz;\n friend bool operator==(const PointWithCovariances & p1, const PointWithCovariances & p2)\n {\n constexpr auto eps = std::numeric_limits::epsilon();\n return common::helper_functions::comparisons::rel_eq(p1.x, p2.x, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.y, p2.y, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.z, p2.z, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.icov_xx, p2.icov_xx, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.icov_xy, p2.icov_xy, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.icov_xz, p2.icov_xz, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.icov_yy, p2.icov_yy, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.icov_yz, p2.icov_yz, eps) &&\n common::helper_functions::comparisons::rel_eq(p1.icov_zz, p2.icov_zz, eps);\n }\n};\nLIDAR_UTILS__DEFINE_FIELD_GENERATOR_FOR_MEMBER(icov_xx);\nLIDAR_UTILS__DEFINE_FIELD_GENERATOR_FOR_MEMBER(icov_xy);\nLIDAR_UTILS__DEFINE_FIELD_GENERATOR_FOR_MEMBER(icov_xz);\nLIDAR_UTILS__DEFINE_FIELD_GENERATOR_FOR_MEMBER(icov_yy);\nLIDAR_UTILS__DEFINE_FIELD_GENERATOR_FOR_MEMBER(icov_yz);\nLIDAR_UTILS__DEFINE_FIELD_GENERATOR_FOR_MEMBER(icov_zz);\n\nusing PointWithCovariancesFieldGenerators = std::tuple<\n point_cloud_msg_wrapper::field_x_generator,\n point_cloud_msg_wrapper::field_y_generator,\n point_cloud_msg_wrapper::field_z_generator,\n field_icov_xx_generator,\n field_icov_xy_generator,\n field_icov_xz_generator,\n field_icov_yy_generator,\n field_icov_yz_generator,\n field_icov_zz_generator>;\n\nusing NdtMapCloudModifier =\n point_cloud_msg_wrapper::PointCloud2Modifier;\n\nusing NdtMapCloudView =\n point_cloud_msg_wrapper::PointCloud2View;\n\n/// This function will check if the covariance is valid based on its eigenvalues. If the covariance\n/// is valid, eigen values smaller than a fraction of the biggest eigen value will be capped to the\n/// threshold. Covariance then will be reconstructed from the modified set of eigen values and\n/// vectors. This should result in increased numerical stability as stated in [Magnusson 2009].\n/// If the covariance is invalid, it will not be updated and false will be returned.\n/// \\tparam Derived Deduced Eigen Matrix type.\n/// \\param covariance [in, out] Covariance matrix to get stabilized.\n/// \\param scaling_factor [in] The ratio between the max. eigen value and the minimum\n/// allowed eigenvalue. Default value is 0.01 as suggested in [Magnusson 2009], page 60.\n/// \\return True if the covariance matrix is valid.\ntemplate\nbool try_stabilize_covariance(\n Eigen::MatrixBase & covariance,\n typename Derived::PlainMatrix::Scalar scaling_factor = 0.1)\n{\n using CovMatrixT = typename Derived::PlainMatrix;\n using ScalarT = typename CovMatrixT::Scalar;\n using IndexT = typename CovMatrixT::Index;\n using SolverT = Eigen::SelfAdjointEigenSolver;\n using VectorT = typename SolverT::RealVectorType;\n\n Eigen::SelfAdjointEigenSolver solver(covariance);\n if (solver.info() != Eigen::Success) {return false;}\n\n VectorT eigen_values = solver.eigenvalues(); // Sorted in increasing order.\n const auto min_eigen_value = eigen_values[0];\n const auto max_eigen_value = eigen_values[eigen_values.size() - IndexT{1U}];\n const auto stabilized_min_eigen_value = scaling_factor * max_eigen_value;\n if (stabilized_min_eigen_value < std::numeric_limits::epsilon()) {return false;}\n if (min_eigen_value > scaling_factor * max_eigen_value) {return true;} // Already stable.\n for (auto i = IndexT{0U}; i < eigen_values.size(); ++i) {\n eigen_values[i] = std::max(eigen_values[i], stabilized_min_eigen_value);\n }\n covariance =\n solver.eigenvectors() * eigen_values.asDiagonal() * solver.eigenvectors().transpose();\n return true;\n}\n\ntemplate\nusing EigenPose = Eigen::Matrix;\ntemplate\nusing EigenTransform = Eigen::Transform;\nusing RosTransform = geometry_msgs::msg::Transform;\nusing RosPose = geometry_msgs::msg::Pose;\nnamespace transform_adapters\n{\n/// Template function to convert a 6D pose to a transformation matrix.\n/// This function should be specialized and implemented for the supported types.\n/// \\tparam PoseT Pose type.\n/// \\tparam TransformT Transform type.\n/// \\param[in] pose pose to convert\n/// \\param[out] transform resulting transform\ntemplate\nvoid pose_to_transform(const PoseT & pose, TransformT & transform);\n\n/// Template function to convert a 6D pose to a transformation matrix.\n/// This function should be specialized and implemented for the supported types.\n/// \\tparam PoseT Pose type.\n/// \\tparam TransformT Transform type.\n/// \\param[in] transform resulting transform\n/// \\param[out] pose pose to convert\ntemplate\nvoid transform_to_pose(const TransformT & transform, PoseT & pose);\n\n\ntemplate\nvoid pose_to_transform(\n const EigenPose & pose,\n EigenTransform & transform)\n{\n static_assert(std::is_floating_point::value, \"Eigen transform should use floating points\");\n transform.setIdentity();\n transform.translation() = pose.head(3);\n transform.rotate(Eigen::AngleAxis(pose(3), Eigen::Vector3d::UnitX()));\n transform.rotate(Eigen::AngleAxis(pose(4), Eigen::Vector3d::UnitY()));\n transform.rotate(Eigen::AngleAxis(pose(5), Eigen::Vector3d::UnitZ()));\n}\n\n/// Specialization to convert from the eigen pose to the ros transform type.\n/// \\tparam T Eigen scalar type\ntemplate\nvoid pose_to_transform(\n const EigenPose & pose,\n RosTransform & transform)\n{\n static_assert(std::is_floating_point::value, \"Eigen pose should use floating points\");\n Eigen::Quaternion eig_rot{Eigen::Quaternion{}.setIdentity()};\n eig_rot.setIdentity();\n eig_rot =\n Eigen::AngleAxis(pose(3), Eigen::Matrix::UnitX()) *\n Eigen::AngleAxis(pose(4), Eigen::Matrix::UnitY()) *\n Eigen::AngleAxis(pose(5), Eigen::Matrix::UnitZ());\n\n decltype(RosTransform::translation) trans;\n decltype(RosTransform::rotation) rot;\n\n trans.set__x(pose(0)).set__y(pose(1)).set__z(pose(2));\n transform.set__translation(trans);\n\n rot.set__x(eig_rot.x()).\n set__y(eig_rot.y()).\n set__z(eig_rot.z()).\n set__w(eig_rot.w());\n transform.set__rotation(rot);\n}\n\n/// Specialization to convert from the eigen pose to the ros pose type.\n/// `pose_to_transform` template is used as conversion to `RosPose`\n/// is identical to conversion to `RosTransform`\n/// \\tparam T Eigen scalar type\ntemplate\nvoid pose_to_transform(\n const EigenPose & pose,\n RosPose & ros_pose)\n{\n static_assert(std::is_floating_point::value, \"Eigen pose should use floating points\");\n Eigen::Quaternion eig_rot{Eigen::Quaternion{}.setIdentity()};\n eig_rot =\n Eigen::AngleAxis(pose(3), Eigen::Matrix::UnitX()) *\n Eigen::AngleAxis(pose(4), Eigen::Matrix::UnitY()) *\n Eigen::AngleAxis(pose(5), Eigen::Matrix::UnitZ());\n\n decltype(RosPose::position) trans;\n decltype(RosTransform::rotation) rot;\n\n trans.set__x(pose(0)).set__y(pose(1)).set__z(pose(2));\n ros_pose.set__position(trans);\n\n rot.set__x(eig_rot.x()).\n set__y(eig_rot.y()).\n set__z(eig_rot.z()).\n set__w(eig_rot.w());\n ros_pose.set__orientation(rot);\n}\n\n/// Specialization to convert from the ros pose type to an eigen one.\n/// \\tparam T Eigen scalar type\ntemplate\nvoid transform_to_pose(const RosTransform & transform, EigenPose & pose)\n{\n static_assert(std::is_floating_point::value, \"Eigen pose should use floating points\");\n const auto & ros_rot = transform.rotation;\n const auto & ros_trans = transform.translation;\n Eigen::Quaternion eig_rot{ros_rot.w, ros_rot.x, ros_rot.y, ros_rot.z};\n pose(0) = ros_trans.x;\n pose(1) = ros_trans.y;\n pose(2) = ros_trans.z;\n\n const auto rot = eig_rot.matrix().eulerAngles(0, 1, 2);\n pose(3) = rot(0);\n pose(4) = rot(1);\n pose(5) = rot(2);\n}\n\n/// Specialization to convert from the ros pose type to an eigen one.\n/// `transform_to_pose` template is used as conversion from `RosPose`\n/// is identical to conversion from `RosTransform`\n/// \\tparam T Eigen scalar type\ntemplate\nvoid transform_to_pose(const RosPose & ros_pose, EigenPose & pose)\n{\n static_assert(std::is_floating_point::value, \"Eigen pose should use floating points\");\n const auto & ros_rot = ros_pose.orientation;\n const auto & ros_trans = ros_pose.position;\n Eigen::Quaternion eig_rot{ros_rot.w, ros_rot.x, ros_rot.y, ros_rot.z};\n pose(0) = ros_trans.x;\n pose(1) = ros_trans.y;\n pose(2) = ros_trans.z;\n\n const auto rot = eig_rot.matrix().eulerAngles(0, 1, 2);\n pose(3) = rot(0);\n pose(4) = rot(1);\n pose(5) = rot(2);\n}\n\n} // namespace transform_adapters\n} // namespace ndt\n} // namespace localization\n} // namespace autoware\n\n#endif // NDT__UTILS_HPP_\n", "meta": {"hexsha": "43237b78d21b985246ad114e5dfcbac81b6e9cf8", "size": 10396, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/localization/ndt/include/ndt/utils.hpp", "max_stars_repo_name": "ruvus/auto", "max_stars_repo_head_hexsha": "25ae62d6e575cae40212356eed43ec3e76e9a13e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 19.0, "max_stars_repo_stars_event_min_datetime": "2021-05-28T06:14:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T10:03:08.000Z", "max_issues_repo_path": "src/localization/ndt/include/ndt/utils.hpp", "max_issues_repo_name": "ruvus/auto", "max_issues_repo_head_hexsha": "25ae62d6e575cae40212356eed43ec3e76e9a13e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-23T16:45:11.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-03T16:59:40.000Z", "max_forks_repo_path": "src/localization/ndt/include/ndt/utils.hpp", "max_forks_repo_name": "ruvus/auto", "max_forks_repo_head_hexsha": "25ae62d6e575cae40212356eed43ec3e76e9a13e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2021-05-29T14:59:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-10T10:03:09.000Z", "avg_line_length": 38.5037037037, "max_line_length": 99, "alphanum_fraction": 0.7408618699, "num_tokens": 2774, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.6187804478040616, "lm_q2_score": 0.480478678047907, "lm_q1q2_score": 0.29731081156278744}} {"text": "/*!@file\n * @copyright This code is licensed under the 3-clause BSD license.\n * Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.\n * See LICENSE.txt for details.\n */\n\n#include \"Molassembler/Interpret.h\"\n\n#include \"Utils/Geometry/AtomCollection.h\"\n#include \"Utils/Bonds/BondOrderCollection.h\"\n#include \"Utils/Bonds/BondDetector.h\"\n\n#include \"Molassembler/Detail/Cartesian.h\"\n#include \"Molassembler/Graph.h\"\n#include \"Molassembler/Graph/GraphAlgorithms.h\"\n#include \"Molassembler/Graph/PrivateGraph.h\"\n#include \"Molassembler/Molecule.h\"\n#include \"Molassembler/Shapes/ContinuousMeasures.h\"\n#include \"Molassembler/Temple/Adaptors/AllPairs.h\"\n#include \"Molassembler/Temple/Functional.h\"\n#include \"Molassembler/Temple/Optionals.h\"\n\n#include \n\nnamespace Scine {\nnamespace Molassembler {\nnamespace Interpret {\nnamespace {\n\ndouble vectorAngle(const Eigen::Vector3d& a, const Eigen::Vector3d& b) {\n return std::acos(\n a.dot(b) / (\n a.norm() * b.norm()\n )\n );\n}\n\nstruct HapticPlaneGeometry {\n double angle;\n double rmsd;\n};\n\nHapticPlaneGeometry hapticPlaneGeometry(\n const AngstromPositions& wrapper,\n const AtomIndex v,\n const std::vector& site\n) {\n const auto& positions = wrapper.positions;\n const unsigned siteSize = site.size();\n\n assert(siteSize >= 1 && \"Passed hapticPlaneGeometry a non-haptic site!\");\n\n Eigen::Vector3d siteCentroid = Eigen::Vector3d::Zero();\n for(AtomIndex siteAtom : site) {\n siteCentroid += positions.row(siteAtom);\n }\n siteCentroid /= siteSize;\n\n if(siteSize == 2) {\n const double frontAngle = Cartesian::angle(\n positions.row(v),\n siteCentroid,\n positions.row(site.front())\n );\n const double backAngle = Cartesian::angle(\n positions.row(v),\n siteCentroid,\n positions.row(site.back())\n );\n\n return HapticPlaneGeometry {\n M_PI / 2.0 - std::min(frontAngle, backAngle),\n 0.0\n };\n }\n\n const Eigen::Vector3d centroidAxis = siteCentroid - positions.row(v).transpose();\n\n Utils::PositionCollection hapticAtoms(siteSize, 3);\n for(unsigned i = 0; i < siteSize; ++i) {\n hapticAtoms.row(i) = positions.row(site.at(i));\n }\n const auto plane = Cartesian::planeOfBestFit(hapticAtoms);\n const double firstAngle = vectorAngle(plane.normal(), centroidAxis);\n const double secondAngle = vectorAngle(plane.normal(), -centroidAxis);\n return HapticPlaneGeometry {\n std::min(firstAngle, secondAngle),\n Cartesian::planeRmsd(plane, hapticAtoms, Temple::iota(siteSize))\n };\n}\n\nboost::optional minimumClassificationProbability(\n const PrivateGraph& graph,\n const AngstromPositions& angstromPositions,\n const AtomIndex v\n) {\n auto sites = GraphAlgorithms::sites(graph, v);\n if(sites.size() <= 1) {\n return boost::none;\n }\n\n const auto& positions = angstromPositions.positions;\n\n const unsigned S = sites.size();\n Eigen::Matrix sitePositions(3, S + 1);\n for(unsigned i = 0; i < S; ++i) {\n Eigen::Vector3d averagePosition = Eigen::Vector3d::Zero();\n for(unsigned j : sites[i]) {\n averagePosition += positions.row(j);\n }\n sitePositions.col(i) = averagePosition / sites[i].size();\n }\n sitePositions.col(S) = positions.row(v);\n\n auto normalizedPositions = Shapes::Continuous::normalize(sitePositions);\n\n // Classify all suitable shapes\n std::vector viableShapes;\n for(const Shapes::Shape shape : Shapes::allShapes) {\n if(Shapes::size(shape) == S) {\n viableShapes.push_back(shape);\n }\n }\n\n const auto classifications = Temple::map(viableShapes,\n [&](const Shapes::Shape shape) -> boost::optional {\n const double measure = Shapes::Continuous::shapeCentroidLast(normalizedPositions, shape).measure;\n return Shapes::Continuous::probabilityRandomCloud(measure, shape);\n }\n );\n\n if(Temple::all_of(classifications)) {\n const double minimumProbability = std::min_element(\n std::begin(classifications),\n std::end(classifications),\n [](const auto& a, const auto& b) -> bool {\n return a.value() < b.value();\n }\n )->value();\n\n return minimumProbability;\n }\n\n return boost::none;\n}\n\nstruct BestRemovals {\n std::vector removals;\n double certainty;\n};\n\nboost::optional bestRemovalFromHapticSite(\n const PrivateGraph& graph,\n const AngstromPositions& positions,\n const AtomIndex v,\n const std::vector>& sites,\n const unsigned hapticSiteIndex\n) {\n const unsigned S = sites.size();\n const std::vector& hapticSite = sites.at(hapticSiteIndex);\n const unsigned hapticSiteSize = hapticSite.size();\n return Temple::accumulate(\n hapticSite,\n boost::optional(boost::none),\n [&](const auto& carry, const AtomIndex siteVertexToRemove) -> boost::optional {\n auto graphCopy = graph;\n graphCopy.removeEdge(graphCopy.edge(v, siteVertexToRemove));\n GraphAlgorithms::updateEtaBonds(graphCopy);\n const auto newSites = GraphAlgorithms::sites(graphCopy, v);\n\n /* Possible effects of bond removal\n * - Separating a haptic ligand into two single-atom ligands,\n * changing shapes\n * - recognizable by size change\n * - accept if new certainty is low or significantly\n * lower than old (factor 0.5)\n * - Improves the haptic plane angle by removing a bad bond\n * - recognized by matching sites and comparing angles\n * - accept if angle halves\n *\n * How to compare cases?\n */\n if(newSites.size() > S) {\n const auto priorCertainty = minimumClassificationProbability(graph, positions, v);\n const auto posteriorCertainty = minimumClassificationProbability(graphCopy, positions, v);\n\n if(priorCertainty && posteriorCertainty) {\n if(\n posteriorCertainty.value() <= 0.01\n || posteriorCertainty.value() <= 0.5 * priorCertainty.value()\n ) {\n return BestRemovals {{siteVertexToRemove}, 1 - *posteriorCertainty};\n }\n }\n } else {\n const auto siteFindIter = Temple::find_if(\n newSites,\n [&](const auto& newSite) -> bool {\n if(newSite.size() != hapticSiteSize - 1) {\n return false;\n }\n\n // Match all vertices except the one to remove\n for(const AtomIndex oldSiteAtomIndex : hapticSite) {\n if(oldSiteAtomIndex == siteVertexToRemove) {\n continue;\n }\n\n if(Temple::find(newSite, oldSiteAtomIndex) == std::end(newSite)) {\n return false;\n }\n }\n\n return true;\n }\n );\n\n if(siteFindIter != std::end(newSites)) {\n const double newHapticAngle = hapticPlaneGeometry(positions, v, *siteFindIter).angle;\n const double newHapticAngleCertainty = 1 - newHapticAngle * 2 / M_PI;\n const double carryCertainty = Temple::Optionals::map(carry,\n [](const auto& removal) { return removal.certainty; }\n ).value_or(0.0);\n if(newHapticAngleCertainty > carryCertainty) {\n return BestRemovals {{siteVertexToRemove}, newHapticAngleCertainty};\n }\n }\n }\n\n return carry;\n }\n );\n}\n\n} // namespace\n\nstd::vector> ComponentMap::invert() const {\n const unsigned nComponents = countComponents();\n\n std::vector<\n std::vector\n > inverseMaps (nComponents);\n\n const unsigned N = map.size();\n for(unsigned i = 0; i < N; ++i) {\n inverseMaps.at(map.at(i)).push_back(i);\n }\n\n return inverseMaps;\n}\n\nstd::vector ComponentMap::apply(\n const Utils::AtomCollection& atomCollection\n) const {\n const unsigned nComponents = countComponents();\n std::vector componentSizes(nComponents, 0);\n for(unsigned i : map) {\n componentSizes.at(i) += 1;\n }\n\n /* Allocate the collections */\n std::vector collections = Temple::map(\n componentSizes,\n [](const unsigned size) { return Utils::AtomCollection(size); }\n );\n std::vector collectionSizeCount(nComponents, 0);\n\n const unsigned N = map.size();\n for(unsigned i = 0; i < N; ++i) {\n const unsigned moleculeIndex = map.at(i);\n Utils::AtomCollection& collection = collections.at(moleculeIndex);\n unsigned& collectionSize = collectionSizeCount.at(moleculeIndex);\n collection.setElement(\n collectionSize,\n atomCollection.getElement(i)\n );\n collection.setPosition(\n collectionSize,\n atomCollection.getPosition(i)\n );\n ++collectionSize;\n }\n\n return collections;\n}\n\nunsigned ComponentMap::countComponents() const {\n assert(!map.empty());\n return *std::max_element(\n std::begin(map),\n std::end(map)\n ) + 1;\n}\n\nstd::vector ComponentMap::apply(\n const AngstromPositions& positions\n) const {\n const unsigned nComponents = countComponents();\n std::vector componentSizes(nComponents, 0);\n for(unsigned i : map) {\n componentSizes.at(i) += 1;\n }\n\n /* Allocate the component position objects */\n std::vector collections = Temple::map(\n componentSizes,\n [](const unsigned size) { return AngstromPositions(size); }\n );\n std::vector collectionSizeCount(nComponents, 0);\n\n const unsigned N = map.size();\n for(unsigned i = 0; i < N; ++i) {\n const unsigned moleculeIndex = map.at(i);\n AngstromPositions& componentPositions = collections.at(moleculeIndex);\n unsigned& collectionSize = collectionSizeCount.at(moleculeIndex);\n componentPositions.positions.row(collectionSize) = positions.positions.row(i);\n ++collectionSize;\n }\n\n return collections;\n}\n\nstd::vector ComponentMap::apply(\n const std::unordered_set& uninterestingAtoms,\n const std::unordered_map& ghostAtomMap\n) const {\n const unsigned nComponents = countComponents();\n std::vector containers(nComponents);\n\n std::vector indicesInComponent (nComponents, 0);\n const unsigned N = size();\n for(unsigned i = 0; i < N; ++i) {\n const unsigned component = map.at(i);\n unsigned long& indexInComponent = indicesInComponent.at(component);\n PeriodicBoundaryDuplicates& componentContainers = containers.at(component);\n\n if(uninterestingAtoms.count(i) > 0) {\n componentContainers.uninterestingAtoms.insert(indexInComponent);\n }\n\n const auto ghostAtomMapIter = ghostAtomMap.find(i);\n if(ghostAtomMapIter != std::end(ghostAtomMap)) {\n auto transformedMappedIndex = apply(ghostAtomMapIter->second);\n assert(transformedMappedIndex.component == component);\n componentContainers.ghostAtomMap.emplace(\n indexInComponent,\n transformedMappedIndex.atomIndex\n );\n }\n\n ++indexInComponent;\n }\n\n return containers;\n}\n\nComponentMap::ComponentIndexPair ComponentMap::apply(const unsigned index) const {\n ComponentIndexPair pair;\n pair.component = map.at(index);\n pair.atomIndex = std::count(\n std::begin(map),\n std::begin(map) + index,\n pair.component\n );\n return pair;\n}\n\nunsigned ComponentMap::invert(const ComponentIndexPair& pair) const {\n unsigned count = 0;\n const unsigned N = map.size();\n for(unsigned i = 0; i < N; ++i) {\n if(map[i] == pair.component) {\n ++count;\n }\n\n if(count == pair.atomIndex + 1) {\n return i;\n }\n }\n\n throw std::out_of_range(\"No match found in component map!\");\n}\n\nstruct MoleculeParts {\n PrivateGraph graph;\n AngstromPositions positions;\n boost::optional<\n std::vector\n > bondStereopermutatorCandidatesOptional;\n};\n\nstruct Parts {\n std::vector precursors;\n ComponentMap componentMap;\n unsigned nZeroLengthPositions = 0;\n};\n\n// Yields a graph structure without element type annotations\nPrivateGraph discretize(\n const Utils::BondOrderCollection& bondOrders,\n const BondDiscretizationOption discretization\n) {\n const PrivateGraph::Vertex N = bondOrders.getSystemSize();\n PrivateGraph graph {N};\n\n if(discretization == BondDiscretizationOption::Binary) {\n for(unsigned i = 0; i < N; ++i) {\n for(unsigned j = i + 1; j < N; ++j) {\n double bondOrder = bondOrders.getOrder(i, j);\n\n if(bondOrder > 0.5) {\n graph.addEdge(i, j, BondType::Single);\n }\n }\n }\n } else if(discretization == BondDiscretizationOption::RoundToNearest) {\n for(unsigned i = 0; i < N; ++i) {\n for(unsigned j = i + 1; j < N; ++j) {\n double bondOrder = bondOrders.getOrder(i, j);\n\n if(bondOrder > 0.5) {\n auto bond = static_cast(\n std::round(bondOrder) - 1\n );\n\n if(bondOrder > 6.5) {\n bond = BondType::Sextuple;\n }\n\n graph.addEdge(i, j, bond);\n }\n }\n }\n }\n\n return graph;\n}\n\nParts construeParts(\n const Utils::ElementTypeCollection& elements,\n const AngstromPositions& angstromWrapper,\n const Utils::BondOrderCollection& bondOrders,\n const BondDiscretizationOption discretization,\n const boost::optional& stereopermutatorThreshold\n) {\n const unsigned N = elements.size();\n\n // Check preconditions\n if(angstromWrapper.positions.rows() != N) {\n throw std::invalid_argument(\n \"Number of positions in angstrom wrapper do not match number of elements\"\n );\n }\n\n if(bondOrders.getSystemSize() != N) {\n throw std::invalid_argument(\n \"Bond order argument system size does not match number of elements\"\n );\n }\n\n PrivateGraph atomCollectionGraph = discretize(bondOrders, discretization);\n\n Parts parts;\n const unsigned numComponents = atomCollectionGraph.connectedComponents(parts.componentMap.map);\n parts.precursors.resize(numComponents);\n\n if(stereopermutatorThreshold) {\n for(auto& precursor : parts.precursors) {\n // Empty-vector-initialize the candidate optionals\n precursor.bondStereopermutatorCandidatesOptional = std::vector {};\n }\n }\n\n // Map from original index to component index\n std::vector indexInComponentMap (N);\n\n /* Must keep a map of atom collection index to precursor index and new\n * precursor atom index in order to transfer edges too\n */\n\n for(unsigned i = 0; i < N; ++i) {\n auto& precursor = parts.precursors.at(\n parts.componentMap.apply(i).component\n );\n\n // Add a new vertex with element information\n const PrivateGraph::Vertex newIndex = precursor.graph.addVertex(elements.at(i));\n\n // Save new index in precursor graph\n indexInComponentMap.at(i) = newIndex;\n\n if(angstromWrapper.positions.row(i).norm() <= 1e-8) {\n parts.nZeroLengthPositions += 1;\n }\n }\n\n // Copy over edges and bond orders\n for(const PrivateGraph::Edge& edge : atomCollectionGraph.edges()) {\n const PrivateGraph::Vertex source = atomCollectionGraph.source(edge);\n const PrivateGraph::Vertex target = atomCollectionGraph.target(edge);\n\n // Both source and target are part of the same component (since they are bonded)\n auto& precursor = parts.precursors.at(\n parts.componentMap.apply(source).component\n );\n\n // Copy over the edge\n precursor.graph.addEdge(\n indexInComponentMap.at(source),\n indexInComponentMap.at(target),\n atomCollectionGraph.bondType(edge)\n );\n\n // If the edge's bond order exceeds the threshold optional\n if(\n stereopermutatorThreshold\n && bondOrders.getOrder(source, target) >= *stereopermutatorThreshold\n ) {\n precursor.bondStereopermutatorCandidatesOptional->emplace_back(\n indexInComponentMap.at(source),\n indexInComponentMap.at(target)\n );\n }\n }\n\n // Split angstrom atom positions and store in precursors\n auto splitPositions = parts.componentMap.apply(angstromWrapper);\n for(unsigned i = 0; i < numComponents; ++i) {\n parts.precursors.at(i).positions = std::move(splitPositions.at(i));\n }\n\n return parts;\n}\n\nMoleculesResult molecules(\n const Utils::ElementTypeCollection& elements,\n const AngstromPositions& angstromWrapper,\n const Utils::BondOrderCollection& bondOrders,\n const BondDiscretizationOption discretization,\n const boost::optional& stereopermutatorThreshold\n) {\n Parts parts = construeParts(\n elements,\n angstromWrapper,\n bondOrders,\n discretization,\n stereopermutatorThreshold\n );\n\n MoleculesResult result;\n\n /* Transform precursors into Molecules. Positions may only be used if there\n * is at most one position very close to (0, 0, 0). Otherwise, we assume that\n * the given positions are faulty or no positional information is present,\n * and only the graph is used to create the Molecules.\n */\n if(parts.nZeroLengthPositions < 2) {\n result.molecules.reserve(parts.precursors.size());\n for(auto& precursor : parts.precursors) {\n result.molecules.emplace_back(\n Graph {std::move(precursor.graph)},\n precursor.positions,\n precursor.bondStereopermutatorCandidatesOptional\n );\n }\n } else {\n result.molecules.reserve(parts.precursors.size());\n for(auto& precursor : parts.precursors) {\n result.molecules.emplace_back(\n Graph {std::move(precursor.graph)}\n );\n }\n }\n\n result.componentMap = std::move(parts.componentMap);\n\n return result;\n}\n\nMoleculesResult molecules(\n const Utils::ElementTypeCollection& elements,\n const AngstromPositions& angstromWrapper,\n const BondDiscretizationOption discretization,\n const boost::optional& stereopermutatorThreshold\n) {\n return molecules(\n elements,\n angstromWrapper,\n Utils::BondDetector::detectBonds(elements, angstromWrapper.getBohr()),\n discretization,\n stereopermutatorThreshold\n );\n}\n\nMoleculesResult molecules(\n const Utils::AtomCollection& atomCollection,\n const Utils::BondOrderCollection& bondOrders,\n const BondDiscretizationOption discretization,\n const boost::optional& stereopermutatorThreshold\n) {\n return molecules(\n atomCollection.getElements(),\n AngstromPositions {atomCollection.getPositions(), LengthUnit::Bohr},\n bondOrders,\n discretization,\n stereopermutatorThreshold\n );\n}\n\nMoleculesResult molecules(\n const Utils::AtomCollection& atomCollection,\n const BondDiscretizationOption discretization,\n const boost::optional& stereopermutatorThreshold\n) {\n AngstromPositions angstromWrapper {atomCollection.getPositions(), LengthUnit::Bohr};\n\n return molecules(\n atomCollection.getElements(),\n angstromWrapper,\n Utils::BondDetector::detectBonds(atomCollection),\n discretization,\n stereopermutatorThreshold\n );\n}\n\n/* Periodic variation of molecule instantiation */\nMoleculesResult molecules(\n const Utils::AtomCollection& atoms,\n const Utils::BondOrderCollection& periodicBonds,\n const std::unordered_set& uninterestingAtoms,\n const std::unordered_map& ghostAtomMap,\n const BondDiscretizationOption discretization,\n const boost::optional& stereopermutatorThreshold\n) {\n const AngstromPositions angstroms {atoms.getPositions(), LengthUnit::Bohr};\n\n Parts parts = construeParts(\n atoms.getElements(),\n angstroms,\n periodicBonds,\n discretization,\n stereopermutatorThreshold\n );\n\n // Refuse to deal with missing coordinates\n if(parts.nZeroLengthPositions > 1) {\n throw std::runtime_error(\"Found multiple coordinates of length zero. Please provide atom positions!\");\n }\n\n const auto periodicContainers = parts.componentMap.apply(uninterestingAtoms, ghostAtomMap);\n\n MoleculesResult result;\n result.molecules.reserve(parts.precursors.size());\n const unsigned N = parts.precursors.size();\n for(unsigned i = 0; i < N; ++i) {\n auto& precursor = parts.precursors.at(i);\n result.molecules.emplace_back(\n Graph {std::move(precursor.graph)},\n precursor.positions,\n precursor.bondStereopermutatorCandidatesOptional,\n periodicContainers.at(i)\n );\n }\n\n // Copy the component map, removing ghost atoms\n if(ghostAtomMap.empty()) {\n result.componentMap = std::move(parts.componentMap);\n } else {\n for(unsigned i = 0; i < parts.componentMap.size(); ++i) {\n if(ghostAtomMap.count(i) > 0) {\n break;\n }\n\n result.componentMap.map.push_back(parts.componentMap.map.at(i));\n }\n }\n\n return result;\n}\n\nGraphsResult graphs(\n const Utils::ElementTypeCollection& elements,\n const AngstromPositions& angstromWrapper,\n const Utils::BondOrderCollection& bondOrders,\n BondDiscretizationOption discretization\n) {\n Parts parts = construeParts(\n elements,\n angstromWrapper,\n bondOrders,\n discretization,\n boost::none\n );\n\n GraphsResult result;\n result.graphs.reserve(parts.precursors.size());\n for(auto& precursor : parts.precursors) {\n result.graphs.emplace_back(std::move(precursor.graph));\n }\n result.componentMap = std::move(parts.componentMap);\n return result;\n}\n\nGraphsResult graphs(\n const Utils::AtomCollection& atomCollection,\n const Utils::BondOrderCollection& bondOrders,\n BondDiscretizationOption discretization\n) {\n return graphs(\n atomCollection.getElements(),\n AngstromPositions {atomCollection.getPositions(), LengthUnit::Bohr},\n bondOrders,\n discretization\n );\n}\n\nstd::vector uncertainBonds(\n const Utils::AtomCollection& atomCollection,\n const Utils::BondOrderCollection& bondOrders\n) {\n std::vector falsePositives;\n\n Parts parts = construeParts(\n atomCollection.getElements(),\n AngstromPositions {atomCollection.getPositions(), LengthUnit::Bohr},\n bondOrders,\n BondDiscretizationOption::Binary,\n boost::none\n );\n\n for(unsigned component = 0; component < parts.precursors.size(); ++component) {\n MoleculeParts& part = parts.precursors[component];\n GraphAlgorithms::updateEtaBonds(part.graph);\n\n std::vector> sketchyClassifications;\n\n for(const PrivateGraph::Vertex v : part.graph.vertices()) {\n /* Detect high uncertainty shape classifications. Adjacent pairs with high\n * uncertainties are candidates for false positives.\n */\n auto classificationUncertainty = minimumClassificationProbability(part.graph, part.positions, v);\n if(classificationUncertainty && *classificationUncertainty >= 0.5) {\n sketchyClassifications.emplace_back(v, *classificationUncertainty);\n }\n }\n\n // NOTE: Cannot remove bonds with overlapping constituent atoms!\n for(const auto& sketchyPair : Temple::Adaptors::allPairs(sketchyClassifications)) {\n const unsigned i = sketchyPair.first.first;\n const unsigned j = sketchyPair.second.first;\n const double i_random = sketchyPair.first.second;\n const double j_random = sketchyPair.second.second;\n\n if(part.graph.edgeOption(i, j)) {\n falsePositives.push_back(\n FalsePositive {\n parts.componentMap.invert(ComponentMap::ComponentIndexPair {component, i}),\n parts.componentMap.invert(ComponentMap::ComponentIndexPair {component, j}),\n i_random * j_random\n }\n );\n }\n }\n }\n\n return falsePositives;\n}\n\nstd::vector badHapticLigandBonds(\n const Utils::AtomCollection& atomCollection,\n const Utils::BondOrderCollection& bondOrders\n) {\n std::vector falsePositives;\n\n // Avoid duplicate bonds in list with reverse i-j\n auto addFalsePositive = [&](unsigned i, unsigned j, double p) {\n if(i > j) {\n std::swap(i, j);\n }\n auto findIter = std::find_if(\n std::begin(falsePositives),\n std::end(falsePositives),\n [=](const FalsePositive& fp) -> bool {\n return fp.i == i && fp.j == j;\n }\n );\n if(findIter == std::end(falsePositives)) {\n falsePositives.push_back(FalsePositive {i, j, p});\n }\n };\n\n Parts parts = construeParts(\n atomCollection.getElements(),\n AngstromPositions {atomCollection.getPositions(), LengthUnit::Bohr},\n bondOrders,\n BondDiscretizationOption::Binary,\n boost::none\n );\n\n for(unsigned component = 0; component < parts.precursors.size(); ++component) {\n MoleculeParts& part = parts.precursors[component];\n GraphAlgorithms::updateEtaBonds(part.graph);\n\n for(const PrivateGraph::Vertex v : part.graph.vertices()) {\n /* Detect haptic shape planes with large angles to the axis defined by the\n * site position and the central atom or with high rms deviations on\n * their plane fit\n */\n const auto sites = GraphAlgorithms::sites(part.graph, v);\n const unsigned S = sites.size();\n for(unsigned siteIndex = 0; siteIndex < S; ++siteIndex) {\n const auto& site = sites.at(siteIndex);\n const unsigned siteSize = site.size();\n if(siteSize == 1) {\n continue;\n }\n\n const auto geometry = hapticPlaneGeometry(part.positions, v, site);\n\n // Less than 30° and a good plane fit indicate the haptic site is fine\n if(geometry.angle < M_PI / 6 && geometry.rmsd < 0.2) {\n continue;\n }\n\n if(siteSize == 2) {\n // Suggest the vertex further from the center\n const double frontDistance = (\n part.positions.positions.row(v)\n - part.positions.positions.row(site.front())\n ).norm();\n const double backDistance = (\n part.positions.positions.row(v)\n - part.positions.positions.row(site.back())\n ).norm();\n const AtomIndex toRemove = frontDistance < backDistance ? site.back() : site.front();\n addFalsePositive(\n parts.componentMap.invert(\n ComponentMap::ComponentIndexPair {component, v}\n ),\n parts.componentMap.invert(\n ComponentMap::ComponentIndexPair {component, toRemove}\n ),\n geometry.angle * 2 / M_PI\n );\n } else {\n const auto suggestedRemovalOption = bestRemovalFromHapticSite(\n part.graph,\n part.positions,\n v,\n sites,\n siteIndex\n );\n if(suggestedRemovalOption) {\n for(const AtomIndex w : suggestedRemovalOption->removals) {\n addFalsePositive(\n parts.componentMap.invert(\n ComponentMap::ComponentIndexPair {component, v}\n ),\n parts.componentMap.invert(\n ComponentMap::ComponentIndexPair {component, w}\n ),\n suggestedRemovalOption->certainty\n );\n }\n }\n }\n }\n }\n }\n return falsePositives;\n}\n\nUtils::BondOrderCollection removeFalsePositives(\n const Utils::AtomCollection& atoms,\n Utils::BondOrderCollection bonds\n) {\n // First do bad haptic bond orders\n auto haptics = badHapticLigandBonds(atoms, bonds);\n while(!haptics.empty()) {\n Temple::sort(haptics);\n FalsePositive& mostLikely = haptics.back();\n bonds.setOrder(mostLikely.i, mostLikely.j, 0.0);\n haptics = badHapticLigandBonds(atoms, bonds);\n }\n\n // Then do uncertain bonds\n auto uncertains = uncertainBonds(atoms, bonds);\n while(!uncertains.empty()) {\n Temple::sort(uncertains);\n FalsePositive& mostLikely = uncertains.back();\n bonds.setOrder(mostLikely.i, mostLikely.j, 0.0);\n uncertains = uncertainBonds(atoms, bonds);\n }\n\n return bonds;\n}\n\n} // namespace Interpret\n} // namespace Molassembler\n} // namespace Scine\n", "meta": {"hexsha": "1ab1ac821acac1fc9fa818862e6a45f27678c104", "size": 27511, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/Molassembler/Interpret.cpp", "max_stars_repo_name": "qcscine/molassembler", "max_stars_repo_head_hexsha": "3b72168477b2d1dee55812517e49d9c3285c50ba", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2020-11-27T14:59:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T10:31:25.000Z", "max_issues_repo_path": "src/Molassembler/Interpret.cpp", "max_issues_repo_name": "qcscine/molassembler", "max_issues_repo_head_hexsha": "3b72168477b2d1dee55812517e49d9c3285c50ba", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Molassembler/Interpret.cpp", "max_forks_repo_name": "qcscine/molassembler", "max_forks_repo_head_hexsha": "3b72168477b2d1dee55812517e49d9c3285c50ba", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2020-12-09T09:21:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-22T15:42:21.000Z", "avg_line_length": 30.5338512764, "max_line_length": 106, "alphanum_fraction": 0.6801279488, "num_tokens": 6500, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.7431679972357831, "lm_q2_score": 0.399811640739795, "lm_q1q2_score": 0.2971272163201459}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"snark.hpp\"\n#include \"utils.cpp\"\n\nusing namespace libsnark;\nusing namespace std;\n\n\nint verifyProof(r1cs_ppzksnark_verification_key verificationKey_in, string proofFileName)\n{\n boost::optional> proof_in;\n \n cout << proofFileName << endl;\n ifstream proofFileIn(proofFileName);\n stringstream proofFromFile;\n if (proofFileIn) {\n proofFromFile << proofFileIn.rdbuf();\n proofFileIn.close();\n } else {\n cout << \"Failed to read from proof file\" << endl;\n return 1;\n }\n\n proofFromFile >> proof_in;\n \n // Hashes to validate against\n bit_vector h_startBalance_bv;\n bit_vector h_endBalance_bv;\n bit_vector h_incoming_bv[noIncomingPayments];\n bit_vector h_outgoing_bv[noOutgoingPayments];\n vector> values = fillValuesFromfile(\"publicInputParameters_multi\");\n h_startBalance_bv = int_list_to_bits_local(values[0], 8);\n h_endBalance_bv = int_list_to_bits_local(values[1], 8);\n \n for (counter = 0; counter < noIncomingPayments; counter++)\n {\n h_incoming_bv[counter] = int_list_to_bits_local(values[counter+2], 8);\n }\n for (counter = 0; counter < noOutgoingPayments; counter++)\n {\n h_outgoing_bv[counter] = int_list_to_bits_local(values[counter+2+noIncomingPayments], 8);\n }\n\n cout << \"proof read ... starting verification\" << endl;\n // Verify the proof\n bool isVerified = verify_payment_multi_proof(verificationKey_in, *proof_in, h_startBalance_bv, h_endBalance_bv, h_incoming_bv, h_outgoing_bv);\n\n if(isVerified){\n cout << \"Proof was verified!!\" << endl;\n return 0;\n } else {\n cout << \"Proof was not verified!!\" << endl;\n return 1;\n }\n}\n\nint main(int argc, char *argv[])\n{\n // Initialize the curve parameters.\n default_r1cs_ppzksnark_pp::init_public_params();\n\n // Read verification key in from file\n r1cs_ppzksnark_verification_key verificationKey_in;\n ifstream fileIn(\"verificationKey_multi\");\n stringstream verificationKeyFromFile;\n if (fileIn) {\n verificationKeyFromFile << fileIn.rdbuf();\n fileIn.close();\n }\n verificationKeyFromFile >> verificationKey_in;\n\n string proofName = \"proof_multi_\";\n string proofNameWithId = proofName + argv[1];\n return verifyProof(verificationKey_in, proofNameWithId);\n}\n\n\n", "meta": {"hexsha": "63b035235b847bea5ed142e51ed91858a2522485", "size": 2474, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/payment_multi_verify_proof.cpp", "max_stars_repo_name": "agiletechvn/ZKP", "max_stars_repo_head_hexsha": "d1294da076585e2a906aa64560a71fc68114c75c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 118.0, "max_stars_repo_stars_event_min_datetime": "2017-08-29T05:25:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T13:59:39.000Z", "max_issues_repo_path": "src/payment_multi_verify_proof.cpp", "max_issues_repo_name": "technologiespro/zero-knowledge-proofs", "max_issues_repo_head_hexsha": "6fdfb0c25ae24e33b6325baa2b261860e89ae087", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 10.0, "max_issues_repo_issues_event_min_datetime": "2017-08-29T03:44:57.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-10T23:39:26.000Z", "max_forks_repo_path": "src/payment_multi_verify_proof.cpp", "max_forks_repo_name": "technologiespro/zero-knowledge-proofs", "max_forks_repo_head_hexsha": "6fdfb0c25ae24e33b6325baa2b261860e89ae087", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 59.0, "max_forks_repo_forks_event_min_datetime": "2017-08-29T01:50:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T13:38:35.000Z", "avg_line_length": 29.1058823529, "max_line_length": 144, "alphanum_fraction": 0.7409054163, "num_tokens": 664, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.29712130790785707}} {"text": "/**\n * \\file common.hh\n * \\brief Headers needed in all headers.\n */\n#ifndef CJ_COMMON_HH_\n#define CJ_COMMON_HH_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define CONJUNCTION\n#define CONJUNCTION_MAX 0\n#define CONJUNCTION_MIN 0\n#define CONJUNCTION_REV 0\n#define CONJUNCTION_VERSION \"0.0.0\"\n\n#if defined(__GNUC__) // Clang also defines __GNUC__\n# define cj_likely(x) (__builtin_expect((x), 1))\n# define cj_unlikely(x) (__builtin_expect((x), 0))\n#else\n# define cj_likely(x) (x)\n# define cj_unlikely(x) (x)\n#endif\n\nnamespace cj {\n\n // Aliases:\n\n using string = std::string;\n\n template\n using vector = std::vector;\n\n template\n using pair = std::pair;\n\n template>\n using flat_set = boost::container::flat_set;\n\n template>\n using flat_map = boost::container::flat_map;\n\n template>\n using flat_multiset = boost::container::flat_multiset;\n\n template>\n using flat_multimap = boost::container::flat_multimap;\n\n template>\n using ordered_set = std::set;\n\n template>\n using ordered_map = std::map;\n\n template>\n using ordered_multiset = std::multiset;\n\n template>\n using ordered_multimap = std::multimap;\n\n template\n using unordered_set = std::unordered_set;\n\n template\n using unordered_map = std::unordered_map;\n\n template\n using unordered_multiset = std::unordered_multiset;\n\n template\n using unordered_multimap = std::unordered_multimap;\n\n // Eigen's vectors and matrices. Aliases for matrices and vectors based on the 's', 'c', 'd', 'z'\n // convention established by BLAS:\n\n template\n using array = Eigen::Array;\n\n template\n using sparse_matrix = Eigen::SparseMatrix;\n\n template\n using matrix = Eigen::Matrix;\n\n template\n using colvec = Eigen::Matrix;\n\n template\n using rowvec = Eigen::Matrix;\n\n // Aliases for matrices/vectors based on BLAS' convention: 's' = float, 'd' = double,\n // 'c' = complex, 'z': complex.\n\n using smatrix = matrix;\n using scolvec = colvec;\n using srowvec = rowvec;\n\n using dmatrix = matrix;\n using dcolvec = colvec;\n using drowvec = rowvec;\n\n using cmatrix = matrix>;\n using ccolvec = colvec>;\n using crowvec = rowvec>;\n\n using zmatrix = matrix>;\n using zcolvec = colvec>;\n using zrowvec = rowvec>;\n\n // Helpers to build eigen objects:\n\n /**\n * \\brief Builds an array with an initializer list.\n */\n template\n constexpr auto make_array(std::initializer_list const& xs) noexcept -> array {\n auto a = array(xs.size());\n auto i = 0u;\n for (auto const& x : xs) {\n a(i++) = x;\n }\n return a;\n }\n\n /**\n * \\brief Builds a column vector with an initializer list.\n */\n template\n constexpr auto make_colvec(std::initializer_list const& xs) noexcept -> colvec {\n auto v = colvec(xs.size());\n auto i = 0u;\n for (auto const& x : xs) {\n v(i++) = x;\n }\n return v;\n }\n\n /**\n * \\brief Builds a row vector with an initializer list.\n */\n template\n constexpr auto make_rowvec(std::initializer_list const& xs) noexcept -> rowvec {\n auto v = rowvec(xs.size());\n auto i = 0u;\n for (auto const& x : xs) {\n v(i++) = x;\n }\n return v;\n }\n\n /**\n * \\brief Builds a matrix with an initializer list.\n */\n template\n constexpr auto make_matrix(std::initializer_list> const& xs) noexcept -> matrix {\n auto const nrows = xs.size();\n if (nrows == 0) {\n return matrix(0, 0);\n }\n auto const ncols = xs.begin()->size();\n auto m = matrix(nrows, ncols);\n auto r = 0u;\n for (auto const& row : xs) {\n auto c = 0u;\n for (auto const& value : row) {\n m(r, c++) = value;\n }\n ++r;\n }\n return m;\n }\n\n // Math constants:\n\n /**\n * \\brief Natural logarithm of 2.\n */\n template\n constexpr T ln2 = T(0.6931471805599453094172321214581765680755L);\n\n /**\n * \\brief Square root of 2.\n */\n template\n constexpr T sqrt2 = T(1.4142135623730950488016887242096980785696L);\n\n /**\n * \\brief Pi. You may have heard about it.\n */\n template\n constexpr T pi = T(3.1415926535897932384626433832795028841971L);\n\n /**\n * \\brief Euler's number.\n */\n template\n constexpr T euler = T(2.7182818284590452353602874713526624977572L);\n\n /**\n * \\brief The golden ratio.\n */\n template\n constexpr T golden = T(1.6180339887498948482045868343656381177203L);\n\n // Helpers:\n\n /**\n * \\brief Get nth element using std::advance.\n */\n template\n inline auto get(Container const& c, size_t n) -> typename Container::value_type const& {\n auto it = c.begin();\n std::advance(it, n);\n return *it;\n }\n\n /**\n * \\brief Whether a container contains a given element.\n */\n template\n inline auto contains(Container const& c, typename Container::value_type const& elem) -> bool {\n return c.find(elem) != c.end();\n }\n\n /**\n * \\brief Checks if left <= x <= right.\n */\n template\n constexpr auto within_eq(T left, T x, T right) noexcept -> bool {\n return left <= x && x <= right;\n }\n\n /**\n * \\brief Checks if left < x < right.\n */\n template\n constexpr auto within(T left, T x, T right) noexcept -> bool {\n return left < x && x < right;\n }\n\n /**\n * \\brief Hashes T and combine with a seed. A version of boost's hash_combine using std::hash.\n */\n template\n constexpr auto std_hash_combine(size_t& seed, T const& t) noexcept -> void {\n seed ^= std::hash{}(t) + 0x9e3779b9 + (seed << 6) + (seed >> 2);\n }\n\n /**\n * \\brief Hashes a range and combine with a seed. A version of boost's hash_range using std::hash.\n */\n template\n constexpr auto std_hash_range(size_t& seed, It fst, It lst) noexcept -> void {\n for (; fst != lst; ++fst) {\n using value_type = typename std::iterator_traits::value_type;\n seed ^= std::hash{}(*fst) + 0x9e3779b9 + (seed << 6) + (seed >> 2);\n }\n }\n\n template\n constexpr auto std_hash_pair_range(size_t& seed, It fst, It lst) noexcept -> void {\n for (; fst != lst; ++fst) {\n std_hash_range(seed, fst->first);\n std_hash_range(seed, fst->second);\n }\n }\n\n} /* end namespace cj */\n\n#endif\n", "meta": {"hexsha": "e33931758d1e07a69aac083dcf80a07c932710b3", "size": 7890, "ext": "hh", "lang": "C++", "max_stars_repo_path": "include/cj/common.hh", "max_stars_repo_name": "PhDP/ConjunctionAI", "max_stars_repo_head_hexsha": "542bfe9bd8bb18b438bec48552f4f5099fef4c2e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2019-11-02T08:36:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-26T17:16:15.000Z", "max_issues_repo_path": "include/cj/common.hh", "max_issues_repo_name": "PhDP/ConjunctionAI", "max_issues_repo_head_hexsha": "542bfe9bd8bb18b438bec48552f4f5099fef4c2e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/cj/common.hh", "max_forks_repo_name": "PhDP/ConjunctionAI", "max_forks_repo_head_hexsha": "542bfe9bd8bb18b438bec48552f4f5099fef4c2e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.9283276451, "max_line_length": 111, "alphanum_fraction": 0.6598225602, "num_tokens": 2122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.5851011542032312, "lm_q2_score": 0.5078118642792044, "lm_q1q2_score": 0.29712130790785707}} {"text": "//\n// Created by joonho on 10.06.19.\n//\n\n#ifndef OLD_RAI_IK_HPP\n#define OLD_RAI_IK_HPP\n\n#include \n#include \n\nclass InverseKinematics {\n\n public:\n InverseKinematics() {\n\n std::cout << \"Launched the IK constructor!\" << std::endl;\n\n ///Hard code all the shits\n PositionBaseToHipInBaseFrame.resize(4);\n positionHipToThighInHipFrame.resize(4);\n positionThighToShankInThighFrame.resize(4);\n positionShankToFootInShankFrame.resize(4);\n PositionBaseToHAACenterInBaseFrame.resize(4);\n\n PositionBaseToHipInBaseFrame[0] << 0.277, 0.116, 0.0;\n PositionBaseToHipInBaseFrame[1] << 0.277, -0.116, 0.0;\n PositionBaseToHipInBaseFrame[2] << -0.277, 0.116, 0.0;\n PositionBaseToHipInBaseFrame[3] << -0.277, -0.116, 0.0;\n\n positionHipToThighInHipFrame[0] << 0.0635, 0.055, 0.0;\n positionHipToThighInHipFrame[1] << 0.0635, -0.055, 0.0;\n positionHipToThighInHipFrame[2] << -0.0635, 0.055, 0.0;\n positionHipToThighInHipFrame[3] << -0.0635, -0.055, 0.0;\n\n positionThighToShankInThighFrame[0] << 0.0, 0.12205, -0.25;\n positionThighToShankInThighFrame[1] << 0.0, -0.12205, -0.25;\n positionThighToShankInThighFrame[2] << 0.0, 0.12205, -0.25;\n positionThighToShankInThighFrame[3] << 0.0, -0.12205, -0.25;\n\n positionShankToFootInShankFrame[0] << 0.1, -0.02, -0.298;\n positionShankToFootInShankFrame[1] << 0.1, 0.02, -0.298;\n positionShankToFootInShankFrame[2] << -0.1, -0.02, -0.298;\n positionShankToFootInShankFrame[3] << -0.1, 0.02, -0.298;\n\n for (size_t i = 0; i < 4; i++) {\n PositionBaseToHAACenterInBaseFrame[i] = PositionBaseToHipInBaseFrame[i];\n PositionBaseToHAACenterInBaseFrame[i][0] += positionHipToThighInHipFrame[i][0];\n d_[i] = positionHipToThighInHipFrame[i][1];\n d_[i] += positionThighToShankInThighFrame[i][1];\n d_[i] += positionShankToFootInShankFrame[i][1];\n }\n\n a1_squared_ = positionThighToShankInThighFrame[0][0] * positionThighToShankInThighFrame[0][0]\n + positionThighToShankInThighFrame[0][2] * positionThighToShankInThighFrame[0][2];\n a2_squared_ = positionShankToFootInShankFrame[0][0] * positionShankToFootInShankFrame[0][0]\n + positionShankToFootInShankFrame[0][2] * positionShankToFootInShankFrame[0][2];\n\n minReach_SP = std::abs(sqrt(a1_squared_) - sqrt(a2_squared_)) + 0.1;\n maxReach_SP = sqrt(a1_squared_) + sqrt(a2_squared_) - 0.05;\n\n minReach = std::sqrt(d_[0] * d_[0] + minReach_SP * minReach_SP);\n maxReach = sqrt(d_[0] * d_[0] + maxReach_SP * maxReach_SP);\n\n KFEOffset_ = atan2(0.1, 0.298);\n }\n\n ~InverseKinematics() = default;\n\n bool solveIK(\n Eigen::Vector3d &legJoints,\n const Eigen::Vector3d &positionBaseToFootInBaseFrame,\n size_t limb) {\n\n Eigen::Vector3d\n positionHipToFootInBaseFrame = positionBaseToFootInBaseFrame - PositionBaseToHAACenterInBaseFrame[limb];\n\n const double d = d_[limb];\n const double dSquared = d * d;\n\n ///Rescaling target\n\n double reach = positionHipToFootInBaseFrame.norm();\n double positionYzSquared = positionHipToFootInBaseFrame.tail(2).squaredNorm();\n if (reach > maxReach) {\n positionHipToFootInBaseFrame /= reach;\n positionHipToFootInBaseFrame *= maxReach;\n positionYzSquared = positionHipToFootInBaseFrame.tail(2).squaredNorm();\n }\n\n if (positionYzSquared < minReach * minReach) {\n positionHipToFootInBaseFrame[1] = d;\n positionHipToFootInBaseFrame[2] = 0.0;\n positionYzSquared = d * d;\n\n double reach_SP = std::abs(positionHipToFootInBaseFrame[0]);\n\n if (reach_SP > maxReach_SP) {\n positionHipToFootInBaseFrame[0] /= reach_SP;\n positionHipToFootInBaseFrame[0] *= maxReach_SP;\n } else if (reach_SP < minReach_SP) {\n positionHipToFootInBaseFrame[0] /= reach_SP;\n positionHipToFootInBaseFrame[0] *= minReach_SP;\n }\n\n }\n\n double rSquared = positionYzSquared - dSquared;\n const double r = std::sqrt(rSquared);\n const double delta = std::atan2(positionHipToFootInBaseFrame.y(),\n -positionHipToFootInBaseFrame.z());\n const double beta = std::atan2(r, d);\n const double qHAA = beta + delta - M_PI_2;\n legJoints[0] = qHAA;\n\n const double l_squared = (rSquared + positionHipToFootInBaseFrame[0] * positionHipToFootInBaseFrame[0]);\n const double phi1 = std::acos((a1_squared_ + l_squared - a2_squared_) * 0.5 / sqrt(a1_squared_ * l_squared));\n const double phi2 = std::acos((a2_squared_ + l_squared - a1_squared_) * 0.5 / sqrt(a2_squared_ * l_squared));\n\n double qKFE = phi1 + phi2 - KFEOffset_;\n\n if (limb < 2) {\n qKFE *= -1.0;\n }\n legJoints[2] = qKFE;\n\n double theta_prime = atan2(positionHipToFootInBaseFrame[0], r);\n double qHFE = phi1 - theta_prime;\n\n if (limb > 1) {\n qHFE = -phi1 - theta_prime;\n }\n legJoints[1] = qHFE;\n return true;\n }\n\n double d_[4];\n\n double a1_squared_;\n double a2_squared_;\n double KFEOffset_;\n double minReach;\n double maxReach;\n double minReach_SP;\n double maxReach_SP;\n\n std::vector positionHipToThighInHipFrame;\n std::vector positionThighToShankInThighFrame;\n std::vector positionShankToFootInShankFrame;\n std::vector PositionBaseToHipInBaseFrame;\n std::vector PositionBaseToHAACenterInBaseFrame;\n\n};\n\n#endif //OLD_RAI_IK_HPP\n", "meta": {"hexsha": "934d008438e9bfc48253bec8fb885e6fb0e2a30e", "size": 5393, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "cerberus_anymal_control/include/cerberus_anymal_control/utils/IK.hpp", "max_stars_repo_name": "heuristicus/cerberus_anymal_locomotion", "max_stars_repo_head_hexsha": "75f53e9a0ea267f62657bd90b9db95a884cd5ccb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2020-04-21T11:37:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T15:30:20.000Z", "max_issues_repo_path": "cerberus_anymal_control/include/cerberus_anymal_control/utils/IK.hpp", "max_issues_repo_name": "heuristicus/cerberus_anymal_locomotion", "max_issues_repo_head_hexsha": "75f53e9a0ea267f62657bd90b9db95a884cd5ccb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2020-04-22T13:23:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-12T17:20:18.000Z", "max_forks_repo_path": "cerberus_anymal_control/include/cerberus_anymal_control/utils/IK.hpp", "max_forks_repo_name": "heuristicus/cerberus_anymal_locomotion", "max_forks_repo_head_hexsha": "75f53e9a0ea267f62657bd90b9db95a884cd5ccb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2020-04-03T07:50:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-04T12:02:11.000Z", "avg_line_length": 34.7935483871, "max_line_length": 113, "alphanum_fraction": 0.6905247543, "num_tokens": 1840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. NO", "lm_q1_score": 0.8104788995148791, "lm_q2_score": 0.3665897363221598, "lm_q1q2_score": 0.29711324606783374}} {"text": "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n/* */\n/* This file is part of the library KASKADE 7 */\n/* see http://www.zib.de/projects/kaskade7-finite-element-toolbox */\n/* */\n/* Copyright (C) 2002-2012 Zuse Institute Berlin */\n/* */\n/* KASKADE 7 is distributed under the terms of the ZIB Academic License. */\n/* see $KASKADE/academic.txt */\n/* */\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\n\n#ifndef ALGORITHM_3_ERROR_ESTIMATOR_EE\n#define ALGORITHM_3_ERROR_ESTIMATOR_EE\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \"algorithm/newton_bridge.hh\"\n#include \"algorithm/adaptationStrategy.hh\"\n#include \"algorithm/errorDistribution.hh\"\n#include \"linalg/jacobiPreconditioner.hh\"\n#include \"fem/forEach.hh\"\n#include \"fem/hierarchicErrorEstimator.hh\"\n#include \"fem/variables.hh\"\n#include \"utilities/enums.hh\"\n#include \"errorEstimationTraits.hh\"\n#include \"lagrangeLinearization.hh\"\n\n// forward declarations\nnamespace Dune\n{\n struct InverseOperatorResult;\n template class FieldVector;\n}\n\nnamespace Kaskade\n{\n struct Dummy{};\n\n template