{"text": "/**\n * \\file boost/numeric/ublasx/operation/pow.hpp\n *\n * \\brief Apply the \\c std::pow function to a vector or matrix expression.\n *\n * Copyright (c) 2015, Marco Guazzone\n * \n * Distributed under the Boost Software License, Version 1.0. (See\n * accompanying file LICENSE_1_0.txt or copy at\n * http://www.boost.org/LICENSE_1_0.txt)\n *\n * \\author Marco Guazzone, marco.guazzone@gmail.com\n */\n\n#ifndef BOOST_NUMERIC_UBLASX_OPERATION_POW_HPP\n#define BOOST_NUMERIC_UBLASX_OPERATION_POW_HPP\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace boost { namespace numeric { namespace ublasx {\n\nusing namespace ::boost::numeric::ublas;\n\nnamespace detail {\n\ntemplate \nstruct matrix_pow_traits\n{\n\ttypedef typename MatrixExprT::matrix_temporary_type result_type;\n};\n\n} // Namespace detail\n\n\n/**\n * \\brief Computes \\a me to the power of \\a p (me^p).\n *\n * If \\a me is a square matrix and \\a p is a positive integer, me^p effectively\n * multiplies \\a me by itself p-1 times.\n * If \\a me is square and nonsingular, me^(-p) effectively multiplies the\n * inverse of \\a me by itself p-1 times.\n *\n * \\note Fractional exponents are not currently supported.\n *\n * \\tparam MatrixExprT The type of the input matrix expression.\n *\n * \\param me The input matrix expression.\n * \\param p The exponent.\n * \\return The result of \\a me to the power of \\a p.\n *\n * \\author Marco Guazzone, marco.guazzone@gmail.com\n */\ntemplate \nBOOST_UBLAS_INLINE\ntypename detail::matrix_pow_traits::result_type pow(matrix_expression const& me, T p)\n{\n\ttypedef typename detail::matrix_pow_traits::result_type result_type;\n\n\tresult_type res;\n\n\tif (p > 0)\n\t{\n\t\tres = me;\n\n\t\t--p;\n\t\twhile (p >= 1)\n\t\t{\n\t\t\tres = prod(res, me);\n\t\t\t--p;\n\t\t}\n\t}\n\telse if (p < 0)\n\t{\n\t\tresult_type inv_me = inv(me);\n\t\tres = inv_me;\n\t\tp = -p;\n\n\t\t--p;\n\t\twhile (p >= 1)\n\t\t{\n\t\t\tres = prod(res, inv_me);\n\t\t\t--p;\n\t\t}\n\t}\n\telse // p == 0\n\t{\n\t\tres = identity_matrix::value_type>(num_rows(me));\n\t}\n\n\treturn res;\n}\n\n}}} // Namespace boost::numeric::ublasx\n\n\n#endif // BOOST_NUMERIC_UBLASX_OPERATION_POW_HPP\n", "meta": {"hexsha": "3e45943b99e68512af3bd62a5f927bc7541c01f3", "size": 2377, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "boost/numeric/ublasx/operation/pow.hpp", "max_stars_repo_name": "comcon1/boost-ublasx", "max_stars_repo_head_hexsha": "290b92b643a944825df99bece3468a4f81518056", "max_stars_repo_licenses": ["BSL-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": "boost/numeric/ublasx/operation/pow.hpp", "max_issues_repo_name": "comcon1/boost-ublasx", "max_issues_repo_head_hexsha": "290b92b643a944825df99bece3468a4f81518056", "max_issues_repo_licenses": ["BSL-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": "boost/numeric/ublasx/operation/pow.hpp", "max_forks_repo_name": "comcon1/boost-ublasx", "max_forks_repo_head_hexsha": "290b92b643a944825df99bece3468a4f81518056", "max_forks_repo_licenses": ["BSL-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": 22.8557692308, "max_line_length": 111, "alphanum_fraction": 0.7114009255, "num_tokens": 678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.853912760387131, "lm_q2_score": 0.7025300573952054, "lm_q1q2_score": 0.5998993805652694}} {"text": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"miMaS/field.h\"\n#include \"miMaS/weno.h\"\n#include \"miMaS/fft.h\"\n#include \"miMaS/array_view.h\"\n#include \"miMaS/poisson.h\"\n\nnamespace math = boost::math::constants;\n\nint main(int,char**)\n{\n\tstd::size_t Nx = 125, Nv = 64;\n\tfield f(boost::extents[Nv][Nx]);\n\n\tf.range.v_min = 0.; f.range.v_max = 2.*math::pi();\n\tf.step.dv = (f.range.v_max-f.range.v_min)/Nv;\n\tf.range.x_min = 0.; f.range.x_max = 1.;\n\tf.step.dx = (f.range.x_max-f.range.x_min)/Nx;\n\tdouble dt = 0.5*f.step.dv;\n\n field f_sol = f;\n\t\n\tublas::vector E (Nx);\n for ( std::size_t i=0 ; i::size_type k=0 ; k::size_type i=0 ; i Edvf = weno::trp_v(f,E);\n\n for ( auto k=0 ; k\n\n#include \"geometrycentral/geometry.h\"\n#include \"geometrycentral/halfedge_mesh.h\"\n#include \"geometrycentral/linear_solvers.h\"\n#include \"geometrycentral/polygon_soup_mesh.h\"\n\n#include \n\n#include \"args/args.hxx\"\n#include \"json/json.hpp\"\n\n#define GLM_ENABLE_EXPERIMENTAL\n#include \"glm/gtx/string_cast.hpp\"\n\n#define STB_IMAGE_IMPLEMENTATION\n#include \"stb_image.h\"\n\n#include \n#include \n\nusing namespace geometrycentral;\nusing std::cerr;\nusing std::cout;\nusing std::endl;\nusing std::string;\n\ndouble objWrapper(unsigned n, const double* x, double* grad, void* f_data);\nvoid angleDefectWrapper(unsigned m, double* result, unsigned n, const double* x, double* gradient, void* func_data);\nvoid validAngleWrapper(unsigned m, double* result, unsigned n, const double* x, double* gradient, void* func_data);\nclass CatData {\n // Initialized stuff\n Geometry* geom;\n HalfedgeMesh* mesh;\n std::string niceName;\n\n // Original mesh information\n VertexData vInd;\n size_t nVerts;\n size_t nHalfedges;\n size_t nCorners;\n size_t dim;\n VertexData angleDefects;\n HalfedgeData hInd;\n CornerData cInd;\n //EdgeData lengths;\n\npublic:\n // Derived Information\n HalfedgeData theta;\n HalfedgeData alpha;\n HalfedgeData beta;\n\n double obj(unsigned n, const double* x, double* grad, void* f_data)\n {\n double accum = 0;\n for (size_t i = 0; i < n; i++)\n {\n accum += pow(x[i],2);\n if (grad) \n {\n grad[i] = 2*x[i];\n }\n }\n return accum;\n }\n \n void angleDefectCalc(unsigned m, double* result, unsigned n, const double* x, double* gradient, void* func_data) \n {\n // initialize angle defect\n for (size_t i = 0; i < m; i++)\n {\n result[i] = - angleDefects[i];\n }\n if (gradient) \n {\n for (size_t i = 0; i < n*m ; i++)\n {\n gradient[i] = 0.;\n }\n }\n //go through halfedges\n for (EdgePtr e : mesh->edges()) \n {\n HalfedgePtr he1 = e.halfedge();\n HalfedgePtr he2 = he1.twin();\n size_t h1 = hInd[he1];\n size_t h2 = hInd[he2];\n size_t v1 = vInd[he1.vertex()];\n size_t v2 = vInd[he2.vertex()];\n result[v1] += x[h1] + x[h2];\n result[v2] += x[h1] + x[h2];\n\n if (gradient) \n {\n gradient[v1 * n + h1] = 1;\n gradient[v2 * n + h1] = 1;\n gradient[v1 * n + h2] = 1;\n gradient[v2 * n + h2] = 1;\n }\n }\n return;\n }\n void validAngleCalc(unsigned m, double* result, unsigned n, const double* x, double* gradient, void* func_data) \n {\n // first coord specifies angle + alphas - 2pi < 0, second specifies -angle -alphas < 0 \n for (CornerPtr c: mesh->corners())\n {\n double curAngle = geom->angle(c);\n result[2 * cInd[c]] = curAngle - 2 * M_PI;\n result[2 * cInd[c] + 1] = - curAngle;\n }\n for (CornerPtr c: mesh->corners())\n {\n size_t h = hInd[c.halfedge()];\n result[2 * cInd[c]] += x[h];\n result[2 * cInd[c] + 1] -= x[h];\n result[2 * cInd[c.next()]] += x[h];\n result[2 * cInd[c.next()] + 1] -= x[h];\n if (gradient) \n {\n gradient[2 * cInd[c] * n + h] = 1;\n gradient[(2 * cInd[c] + 1) * n + h] = -1;\n gradient[2 * cInd[c.next()] * n + h] = 1;\n gradient[(2 * cInd[c.next()] + 1) * n + h] = -1;\n }\n }\n return;\n }\n\n void optimize() {\n nlopt::opt opt(nlopt::LN_COBYLA, nHalfedges);\n opt.set_min_objective(&objWrapper, this);\n opt.set_lower_bounds(-2 * M_PI);\n opt.set_upper_bounds(2 * M_PI);\n\n std::vector tol1(nVerts, 1e-8);\n std::vector tol2(2 * nCorners, 1e-8);\n\n opt.add_equality_mconstraint(&angleDefectWrapper, this, tol1);\n opt.add_inequality_mconstraint(&validAngleWrapper, this, tol2);\n\n //opt.add_inequality_constraint(myconstraint, &data[0], 1e-8);\n //opt.add_inequality_constraint(myconstraint, &data[1], 1e-8);\n opt.set_xtol_rel(1e-4);\n\tstd::vector x(nHalfedges, 0);\n double minf;\n try {\n nlopt::result result = opt.optimize(x, minf);\n std::cout << \"found minimum\" << std::setprecision(10) << minf << std::endl;\n } catch (std::exception& e) {\n std::cout << \"nlopt failed: \" << e.what() << std::endl;\n }\n }\n\n CatData(std::string filename) {\n niceName = polyscope::utilities::guessNiceNameFromPath(filename);\n mesh = new HalfedgeMesh(PolygonSoupMesh(filename), geom);\n polyscope::registerSurfaceMesh(niceName, geom);\n\n vInd = mesh->getVertexIndices();\n nVerts = mesh->nVertices();\n hInd = mesh->getHalfedgeIndices();\n nHalfedges = mesh->nHalfedges();\n cInd = mesh->getCornerIndices();\n nCorners = mesh->nCorners();\n dim = nVerts + nHalfedges;\n\n theta = HalfedgeData(mesh);\n alpha = HalfedgeData(mesh);\n beta = HalfedgeData(mesh);\n\n geom->getVertexAngleDefects(angleDefects);\n optimize();\n delete geom;\n delete mesh;\n }\n};\n\ndouble objWrapper(unsigned n, const double* x, double* grad, void* f_data)\n{\n return static_cast(f_data)->obj(n, x, grad, NULL);\n}\n\nvoid angleDefectWrapper(unsigned m, double* result, unsigned n, const double* x, double* gradient, void* func_data) \n{\n static_cast(func_data)->angleDefectCalc(m, result, n, x, gradient, NULL);\n}\n\nvoid validAngleWrapper(unsigned m, double* result, unsigned n, const double* x, double* gradient, void* func_data)\n{\n static_cast(func_data)->validAngleCalc(m, result, n, x, gradient, NULL);\n}\n\nint main(int argc, char** argv) {\n // Configure the argument parser\n /*args::ArgumentParser parser(\"A simple demo of Polyscope.\\nBy \"\n \"Nick Sharp (nsharp@cs.cmu.edu)\",\n \"\");\n args::PositionalList files(parser, \"files\", \"One or more files to visualize\");\n */\n // Options\n polyscope::options::autocenterStructures = true;\n // Initialize polyscope\n polyscope::init();\n CatData* c = new CatData(\"C:/spot1.obj\");\n delete c;\n // Show the gui\n polyscope::show();\n\n return 0;\n}\n\n\n\n/* class CatDataOld {\n // Initialized stuff\n Geometry* geom;\n HalfedgeMesh* mesh;\n std::string niceName;\n\n // Original mesh information\n VertexData vInd;\n size_t nVerts;\n size_t nHalfedges;\n size_t dim;\n VertexData angleDefects;\n HalfedgeData hInd;\n EdgeData lengths;\n\n public:\n // Derived Information\n HalfedgeData finalCurvature;\n VertexData multiplier;\n\n HalfedgeData theta;\n HalfedgeData d;\n HalfedgeData alpha;\n HalfedgeData beta;\n\n EdgeData badEdges;\n EdgeData netEdgeCurvature;\n EdgeData negEdges;\n\n // Solves the optimization problem\n void solveOptMatrix() {\n Eigen::SparseMatrix d0 = Eigen::SparseMatrix(dim, dim);\n std::vector> tripletList;\n Vector rhs = Vector(dim);\n // cout << dim << endl;\n for (size_t i = 0; i < nHalfedges; i++) {\n tripletList.emplace_back(i, i, 1.);\n rhs[i] = 0.;\n }\n\n for (size_t i = nHalfedges; i < dim; i++) {\n rhs[i] = 2 * angleDefects[mesh->vertex(i - nHalfedges)];\n }\n for (EdgePtr e : mesh->edges()) {\n HalfedgePtr h1 = e.halfedge();\n HalfedgePtr h2 = h1.twin();\n size_t v1 = vInd[h1.vertex()];\n size_t v2 = vInd[h2.vertex()];\n tripletList.emplace_back(nHalfedges + v1, hInd[h1], lengths[e]);\n tripletList.emplace_back(nHalfedges + v1, hInd[h2], lengths[e]);\n tripletList.emplace_back(nHalfedges + v2, hInd[h1], lengths[e]);\n tripletList.emplace_back(nHalfedges + v2, hInd[h2], lengths[e]);\n\n tripletList.emplace_back(hInd[h1], nHalfedges + v1, lengths[e]);\n tripletList.emplace_back(hInd[h2], nHalfedges + v1, lengths[e]);\n tripletList.emplace_back(hInd[h1], nHalfedges + v2, lengths[e]);\n tripletList.emplace_back(hInd[h2], nHalfedges + v2, lengths[e]);\n }\n d0.setFromTriplets(tripletList.begin(), tripletList.end());\n // cout << \"Matrix built\" << endl;\n\n Eigen::SparseLU> solver;\n solver.compute(d0);\n if (solver.info() != Eigen::Success) {\n cout << \"solving failed\" << endl;\n }\n Vector solution = solver.solve(rhs);\n if (solver.info() != Eigen::Success) {\n cout << \"solving failed\";\n }\n // cout << \"Matrix solved\";\n for (size_t i = 0; i < nHalfedges; i++) {\n finalCurvature[i] = solution[i];\n }\n for (size_t i = nHalfedges; i < dim; i++) {\n multiplier[i - nHalfedges] = solution[i];\n }\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Original Curvature\", angleDefects);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Curvature change\", finalCurvature);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Lagrange Multiplier\", multiplier);\n return;\n }\n // Updates the straight distances between edges, then checks for bad distances\n void updateDistances() {\n size_t bad_halfedges = 0;\n // Initialize all distances first\n for (HalfedgePtr h : mesh->allHalfedges()) {\n theta[h] = lengths[h.edge()] * finalCurvature[h];\n // Basic constraint\n if (theta[h] < 2. * M_PI && theta[h] > -2. * M_PI) {\n d[h] = (theta[h] == 0 ? lengths[h.edge()] : 2 * sin(theta[h] / 2) / finalCurvature[h]);\n } else {\n bad_halfedges++;\n badEdges[h.edge()] = true;\n }\n }\n cout << \"Bad angles:\" << bad_halfedges << endl;\n }\n // Updates angles based on distances, checks for self intersection\n void updateAngles() {\n size_t bad_halfedges = 0;\n for (HalfedgePtr h : mesh->allHalfedges()) {\n double ij = d[h];\n double jk = d[h.next()];\n double ki = d[h.next().next()];\n double cosAngle = (pow(ij, 2) + pow(ki, 2) - pow(jk, 2)) / (2 * ij * ki);\n\n if (cosAngle > 1.) {\n alpha[h] = 0;\n bad_halfedges++;\n badEdges[h.edge()] = true;\n } else if (cosAngle < -1.) {\n alpha[h] = M_PI;\n // alpha[h] = 10000;\n bad_halfedges++;\n badEdges[h.edge()] = true;\n } else {\n alpha[h] = acos(cosAngle);\n }\n }\n cout << \"Bad distances:\" << bad_halfedges << endl;\n for (VertexPtr v : mesh->vertices()) {\n angleDefects[v] = 2 * M_PI;\n }\n\n bad_halfedges = 0;\n for (HalfedgePtr h : mesh->allHalfedges()) {\n double betaA = alpha[h] + (theta[h] + theta[h.next().next()]) / 2.;\n angleDefects[h.vertex()] -= betaA;\n beta[h] = betaA;\n if (betaA > 2 * M_PI || betaA < 0.) {\n // cout << betaA << endl;\n bad_halfedges++;\n badEdges[h.edge()] = true;\n }\n }\n cout << \"Self intersection:\" << bad_halfedges << endl;\n }\n\n double averageAngleDefect() {\n double accum = 0;\n for (size_t i = 0; i < nVerts; i++) {\n accum += abs(angleDefects[i]);\n }\n return accum / nVerts;\n }\n\n void checkNegedges() {\n size_t neg_edges = 0;\n for (EdgePtr E : mesh->edges()) {\n netEdgeCurvature[E] = finalCurvature[E.halfedge()] + finalCurvature[E.halfedge().twin()];\n if (netEdgeCurvature[E] < 0) {\n negEdges[E] = true;\n neg_edges++;\n }\n }\n cout << \"Neg edges:\" << neg_edges << endl;\n }\n CatDataOld(std::string filename) {\n niceName = polyscope::utilities::guessNiceNameFromPath(filename);\n mesh = new HalfedgeMesh(PolygonSoupMesh(filename), geom);\n polyscope::registerSurfaceMesh(niceName, geom);\n\n vInd = mesh->getVertexIndices();\n nVerts = mesh->nVertices();\n hInd = mesh->getHalfedgeIndices();\n nHalfedges = mesh->nHalfedges();\n dim = nVerts + nHalfedges;\n\n finalCurvature = HalfedgeData(mesh);\n multiplier = VertexData(mesh);\n theta = HalfedgeData(mesh);\n d = HalfedgeData(mesh);\n alpha = HalfedgeData(mesh);\n beta = HalfedgeData(mesh);\n badEdges = EdgeData(mesh, false);\n netEdgeCurvature = EdgeData(mesh);\n negEdges = EdgeData(mesh, false);\n\n geom->getVertexAngleDefects(angleDefects);\n geom->getEdgeLengths(lengths);\n for (size_t i = 0; i < 1000; i++) {\n cout << \"Starting Iteration \" << i << endl;\n solveOptMatrix();\n updateDistances();\n updateAngles();\n cout << \"Average angle defect: \" << averageAngleDefect() << endl;\n cout << \"Done\" << endl;\n }\n checkNegedges();\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Central angles\", theta);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Interior angles\", alpha);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Straight distances\", d);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Exterior angles\", beta);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Final Angle Defect\", angleDefects);\n polyscope::getSurfaceMesh(niceName)->addQuantity(\"Net Edge Curvature\", netEdgeCurvature);\n polyscope::getSurfaceMesh(niceName)->addSubsetQuantity(\"Bad edges\", badEdges);\n polyscope::getSurfaceMesh(niceName)->addSubsetQuantity(\"Neg edges\", negEdges);\n delete geom;\n delete mesh;\n }\n}; */", "meta": {"hexsha": "324ef019fdbfe96ab2696e6db3716b9b97979616", "size": 13478, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "old/CAT-Flattening-v1.cpp", "max_stars_repo_name": "elu00/CATOpt", "max_stars_repo_head_hexsha": "5ea6e09b98488745d8f82a95bc34db14270ee5d7", "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": "old/CAT-Flattening-v1.cpp", "max_issues_repo_name": "elu00/CATOpt", "max_issues_repo_head_hexsha": "5ea6e09b98488745d8f82a95bc34db14270ee5d7", "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": "old/CAT-Flattening-v1.cpp", "max_forks_repo_name": "elu00/CATOpt", "max_forks_repo_head_hexsha": "5ea6e09b98488745d8f82a95bc34db14270ee5d7", "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": 32.1670644391, "max_line_length": 116, "alphanum_fraction": 0.6081762873, "num_tokens": 3811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.849971190859164, "lm_q2_score": 0.7057850278370112, "lm_q1q2_score": 0.5998969406011926}} {"text": "/*\n * eig.hpp:\n * Computing all matrix eigenvalues and all eigenvectors A*V=V*D\n *\n * written\tJun. 4, 2015\tA. Takayasu\n * modified\tby Masahide Kashiwagi\n * modified Oct. 11, 2015 A. Takayasu\n */\n\n#ifndef EIG_HPP\n#define EIG_HPP\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// Eigenvalue computation using QR method for non-symmetric matrix\n\nnamespace kv {\n\nnamespace ub = boost::numeric::ublas;\n\ntemplate bool house(const ub::matrix& x, ub::matrix& v, T& beta)\n{\n\t// function [v,beta] = house(x)\n\t// n = length(x);\n\tint n = x.size1();\n\tint i;\n\tT sigma, mu;\n\tv.resize(n,1);\n\tv(0,0) = 1.;\n\tsigma = 0.;\n\tfor (i=1; i bool hess(const ub::matrix& A, ub::matrix& Q, ub::matrix& H)\n{\n\tint i,k=0;\n\tT beta;\n\tub::vector vec_tmp;\n\n\t// n = size(A,2);\n\tint n = A.size1();\n\tif (n != A.size2()) return false;// Square matrix only\n\n\t// Q = eye(n);\n\tub::matrix x, v, mat_H;\n\tQ = ub::identity_matrix(n);\n\tH = A;\n\n\tfor (k = 0; k < n-2; k++) {\n\t\t// [v,beta] = house(H(k+1:n,k));\n\t\tx=ub::project(H,ub::range(k+1,n),ub::range(k,k+1));\n\t\thouse(x,v,beta);\n\t\t// mat_H = eye(n-k) - beta*v*(v');\n\t\tmat_H = ub::identity_matrix(n-k-1) - beta*prod(v,trans(v));\n\t\t// H(k+1:n,k) = [mat_H(1,:)*A(k+1:n,k);zeros(n-k-1,1)];\n\t\tvec_tmp = prod(row(mat_H,0),ub::project(H,ub::range(k+1,n),ub::range(k,k+1)));\n\t\tH(k+1,k) = vec_tmp(0);\n\t\tfor (i=k+2;i bool francisQR(ub::matrix& Q, ub::matrix& H)\n{\n\t// double tol=1e-15; // Little bit strong!!!\n\tT tol = std::numeric_limits::epsilon();\n\tint n = H.size1();\n\t// % p indicates the 'active' matrix size\n\tint p = n, q, r;\n\tT s,t,x,y,z,beta;\n\tub::matrix v, mat_tmp, mat_tmp2, mat_T;\n\tmat_tmp.resize(3,1);\n\tmat_tmp2.resize(2,1);\n\n\twhile (p > 2) {\n\t\tq = p-1;\n\t\ts = H(q-1,q-1) + H(p-1,p-1);\n\t\tt = H(q-1,q-1)*H(p-1,p-1) - H(q-1,p-1)*H(p-1,q-1);\n\t\t// % compute first 3 elements of first column of M\n\t\tx = H(0,0)*H(0,0)+H(0,1)*H(1,0)-s*H(0,0)+t;\n\t\ty = H(1,0)*(H(0,0)+H(1,1)-s);\n\t\tz = H(1,0)*H(2,1);\n\t\tfor (int k = 0; k < p-2; k++) {\n\t\t\tmat_tmp(0,0) = x;\n\t\t\tmat_tmp(1,0) = y;\n\t\t\tmat_tmp(2,0) = z;\n\t\t\t// [v,beta] = house([x,y,z].');\n\t\t\thouse(mat_tmp,v,beta);\n\t\t\tr = fmax(1,k); // r = max(1,k); Need math.h???\n\t\t\t// T = eye(3) - beta*v*(v');\n\t\t\tmat_T = ub::identity_matrix(3) - beta*prod(v,trans(v));\n\t\t\t// H(k+1:k+3,r:n) = T*H(k+1:k+3,r:n);\n\t\t\tub::project(H,ub::range(k,k+3),ub::range(r-1,n)) = prod(mat_T,ub::project(H,ub::range(k,k+3),ub::range(r-1,n)));\n\t\t\tr = fmin(k+4,p);\n\t\t\t// H(1:r,k+1:k+3) = H(1:r,k+1:k+3)*T;\n\t\t\tub::project(H,ub::range(0,r),ub::range(k,k+3)) = prod(ub::project(H,ub::range(0,r),ub::range(k,k+3)),mat_T);\n\t\t\t// Q(:,k+1:k+3) = Q(:,k+1:k+3)*T;\n\t\t\tub::project(Q,ub::range(0,n),ub::range(k,k+3)) = prod(ub::project(Q,ub::range(0,n),ub::range(k,k+3)),mat_T);\n\t\t\t// x = H(k+2,k+1);\n\t\t\tx = H(k+1,k);\n\t\t\t// y = H(k+3,k+1);\n\t\t\ty = H(k+2,k);\n\t\t\t// if k(2) - beta*prod(v,trans(v));\n\t\t// H(q:p,p-2:n) = T'*H(q:p,p-2:n);\n\t\tub::project(H,ub::range(q-1,p),ub::range(p-3,n)) = prod(mat_T,ub::project(H,ub::range(q-1,p),ub::range(p-3,n)));\n\t\t// H(1:p,p-1:p) = H(1:p,p-1:p)*T;\n\t\tub::project(H,ub::range(0,p),ub::range(p-2,p)) = prod(ub::project(H,ub::range(0,p),ub::range(p-2,p)),mat_T);\n\t\t// Q(:,q:p) = Q(:,q:p)*T;\n\t\tub::project(Q,ub::range(0,n),ub::range(q-1,p)) = prod(ub::project(Q,ub::range(0,n),ub::range(q-1,p)),mat_T);\n\t\t// check for convergence\n\t\t// if abs(H(p,q)) < tol*(abs(H(q,q))+abs(H(p,p)))\n\t\t// if (fabs(H(p-1,q-1)) < tol*(fabs(H(q-1,q-1) + fabs(H(p-1,p-1)))))\n\t\tusing std::abs;\n\t\tif (abs(H(p-1,q-1)) < tol*(abs(H(q-1,q-1) + abs(H(p-1,p-1))))) {\n\t\t\tH(p-1,q-1) = (T) 0;\n\t\t\tp--;\n\t\t} else if (abs(H(p-2,q-2)) < tol*(abs(H(q-2,q-2)) + fabs(H(q-1,q-1)))){\n\t\t\tH(p-2,q-2) = (T) 0;\n\t\t\tp-=2;\n\t\t}\n\t}\n\treturn true;\n}\n\ntemplate bool lu_factorize_comp(ub::matrix >& A, ub::vector& p)// Numerical recipe in C (ludcmp)\n{\n int i,j,k,imax;\n int n = A.size1();\n\n ub::vector vv;\n vv.resize(n);\n\n T big, temp;\n kv::complex sum, dum;\n\n using std::abs;\n\n for (i = 0; i < n; i++) {\n big = 0.0;\n for (j = 0; j < n; j++) {\n if ((temp = abs(A(i,j))) > big) {\n big = temp;\n }\n }\n if (big == 0.0) {\n std::cout << \"Singular matrix in lu_factorize_comp\" << std::endl;\n return false;\n }\n vv(i) = 1.0/big;\n }\n\n for (j = 0; j < n; j++) {\n for (i = 0; i < j; i++) {\n sum = A(i,j);\n for (k = 0; k < i; k++) {\n sum -= A(i,k)*A(k,j);\n }\n A(i,j) = sum;\n }\n big = 0.0;\n for (i = j; i < n; i++) {\n sum = A(i,j);\n for (k = 0; k < j; k++) {\n sum -= A(i,k)*A(k,j);\n }\n A(i,j) = sum;\n if ((temp=vv(i)*abs(sum)) >= big) {\n big = temp;\n imax = i;\n }\n }\n if (j != imax) {\n for (k = 0; k < n; k++) {\n dum = A(imax,k);\n A(imax,k) = A(j,k);\n A(j,k) = dum;\n }\n vv(imax) = vv(j);\n }\n p(j) = imax;\n if (abs(A(j,j)) == 0) {\n std::cout << \"Singular matrix in lu_factorize_comp\" << std::endl;\n return false;\n }\n if (j != n) {\n dum = 1./(A(j,j));\n for (i = j+1; i < n; i++) {\n A(i,j) *= dum;\n }\n }\n }\n return true;\n}\n\ntemplate bool lu_substitute_comp(const ub::matrix >& A, const ub::vector& p, ub::vector >& b)// Numerical recipe in C (lubksb)\n{\n int i, ii=0, ip, j;\n int n = A.size1();\n kv::complex sum;\n\n using std::abs;\n\n for (i = 0; i < n; i++) {\n ip = p(i);\n sum = b(ip);\n b(ip) = b(i);\n if (ii==0) {\n for (j = ii; j <= i-1; j++) {\n sum -= A(i,j)*b(j);\n }\n } else if (abs(sum) != 0) {\n ii = i;\n }\n b(i) = sum;\n }\n for (i = n-1; i >= 0; i--) {\n sum = b(i);\n for (j = i+1; j < n; j++) {\n sum -= A(i,j)*b(j);\n }\n b(i) = sum/A(i,i);\n }\n return true;\n}\n\ntemplate bool eig2by2(const ub::matrix& P, const ub::matrix& A, ub::matrix< kv::complex >& V, ub::matrix< kv::complex >& D)\n{\n\tint i, j, k, l;\n\tT tra, det, x_norm;\n\tkv::complex tmp, tmp1, am, ap;\n\tkv::complex b1, b2;\n\tkv::complex a11, a12, a21, a22, ck;\n\tint n = A.size1();// n = size(A,2);\n\t// X = eye(n,n); Orthogonal matrix\n\tub::matrix< kv::complex > X;\n\tub::vector< kv::complex > x;\n\tX.resize(n,n);\n\tfor (i = 0; i < n; i++) {\n\t\tX(i,i) = 1.;\n\t}\n\tD.resize(n,n);// Eigen value matrix (diagonal)\n\n\ti=1;\n\t// Compute eigenvalue\n\twhile (i<=n) {\n\t\tif (i!=n) {\n\t\t\tj = i+1;\n\t\t}\n\t\tif (A(j-1,i-1) == 0 || i==n) {\n\t\t\t// Eigen value is diagonal element\n\t\t\tD(i-1,i-1) = A(i-1,i-1);\n\t\t\ti++;\n\t\t} else {\n\t\t\t// If A contains 2 by 2 block on the diagonal,\n\t\t\t// compute a real pair or a complex conjugate pair.\n\t\t\ttra = A(i-1,i-1) + A(j-1,j-1);\n\t\t\tdet = A(i-1,i-1)*A(j-1,j-1)-A(i-1,j-1)*A(j-1,i-1);\n\t\t\ttmp = tra*tra-4*det;// Complex!\n\t\t\tusing std::sqrt;\n\t\t\ttmp1 = sqrt(tmp);\n\t\t\tam = 0.5*(tra + tmp1);\n\t\t\tap = 0.5*(tra - tmp1);\n\t\t\tusing std::abs;\n\t\t\tif (abs(A(i-1,i-1)-am)/abs(am) < 1) {\n\t\t\t\tD(i-1,i-1) = am;\n\t\t\t\tD(j-1,j-1) = ap;\n\t\t\t} else {\n\t\t\t\tD(i-1,i-1) = ap;\n\t\t\t\tD(j-1,j-1) = am;\n\t\t\t}\n\t\t\ti += 2;\n\t\t}\n\t}\n\t// std::cout << \"D\" << D << std::endl;\n\t// D(0,0).imag() = -D(0,0).imag();\n\t// std::cout << \"conj(D)\" << D << std::endl;\n\n\n\t// Compute eigenvector by backward substitution\n\tbool flag = true;\n\tfor (i = 1; i <= n; i++) {\n\t\tj = i;\n\t\tif (flag) {\n\t\t\t// Compute jth element of ith eigenvector X(j,i)\n\t\t\twhile (j>0) {\n\t\t\t\tk = fmin(n,j+1);\n\t\t\t\tl = fmax(1,j-1);\n\t\t\t\tif (i==j) {\n\t\t\t\t\tif (A(k-1,j-1) != 0 && k!=j) {\n\t\t\t\t\t\t// Block diagonal [A(j,j), A(j,j+1); A(j+1,j), A(j+1,j+1)] appears\n\t\t\t\t\t\tusing std::abs;\n\t\t\t\t\t\tif (abs(A(j,j)-D(i-1,i-1)) > abs(A(j-1,j))) {\n\t\t\t\t\t\t\tX(j,i-1) = -A(j,j-1) / (A(j,j)-D(i-1,i-1));\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tX(j,i-1) = -(A(j-1,j-1)-D(i-1,i-1))/A(j-1,j);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (D(j-1,j-1).imag() != -D(j-1,j-1).imag()) {\n\t\t\t\t\t\t\t// Conjugate pair X(j,i) = 1+0*1i;\n\t\t\t\t\t\t\tflag = false; //Conjugate pair flag (flag=false means the next eigenvector is conjugate of ith vector)\n\t\t\t\t\t\t}\n\t\t\t\t\t\tj--;\n\t\t\t\t\t} else if (A(j-1,l-1) != 0 && l!=j) {\n\t\t\t\t\t\t// Block diagonal [A(j-1,j-1), A(j-1,j); A(j,j-1), A(j,j)] appears X(j,i)=1\n\t\t\t\t\t\tusing std::abs;\n\t\t\t\t\t\tif (abs(A(j-2,j-2)-D(i-1,i-1)) > abs(A(j-1,j-2))) {\n\t\t\t\t\t\t\tX(j-2,i-1) = -A(j-2,j-1)/(A(j-2,j-2)-D(i-1,i-1));\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tX(j-2,i-1) = -(A(j-1,j-1)-D(i-1,i-1))/A(j-1,j-2);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (D(j-1,j-1).imag() != -D(j-1,j-1).imag()) {\n\t\t\t\t\t\t\t// Conjugate pair X(j,j) = 1+0*1i;\n\t\t\t\t\t\t\tflag = false;// Conjugate pair flag (flag=false means the next eigenvector is conjugate of ith vector)\n\t\t\t\t\t\t}\n\t\t\t\t\t\tj -= 2;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// A(i,i) is eigen value\n\t\t\t\t\t\tj--;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (A(j-1,l-1)!=0 && l!=j) {\n\t\t\t\t\t\t// Block diagonal [A(j-1,j-1), A(j-1,j); A(j,j-1), A(j,j)] appears\n\t\t\t\t\t\t// Real pair\n\t\t\t\t\t\tb1=0; b2=0;\n\t\t\t\t\t\tfor (k = j+1; k <= fmin(i+1,n); k++) {\n\t\t\t\t\t\t\tb1 += A(j-2,k-1)*X(k-1,i-1);\n\t\t\t\t\t\t\tb2 += A(j-1,k-1)*X(k-1,i-1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\ta11 = A(j-2,j-2)-D(i-1,i-1);\n\t\t\t\t\t\ta12 = A(j-2,j-1);\n\t\t\t\t\t\ta21 = A(j-1,j-2);\n\t\t\t\t\t\ta22 = A(j-1,j-1)-D(i-1,i-1);\n\t\t\t\t\t\tub::matrix > LU(2,2);\n\t\t\t\t\t\tLU(0,0) = a11; LU(0,1) = a12; LU(1,0) = a21; LU(1,1) = a22;\n\t\t\t\t\t\tub::vector > b(2);\n\t\t\t\t\t\tb(0) = b1; b(1) = b2;\n\t\t\t\t\t\tub::vector pm(n);\n\t\t\t\t\t\tlu_factorize_comp(LU,pm);\n\t\t\t\t\t\tlu_substitute_comp(LU,pm,b);\n\t\t\t\t\t\t// ck = -1/(a11*a22-a12*a21);\n\t // X(j-2,i-1) = ck*(a22*b1-a12*b2);\n\t // X(j-1,i-1) = ck*(-a21*b1+a11*b2);\n\t\t\t\t\t\tX(j-2,i-1) = b(0);\n\t\t\t\t\t\tX(j-1,i-1) = b(1);\n\t\t\t\t\t\tj -= 2;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// A(i,i) is eigen value\n\t\t\t\t\t\tfor (k = j+1; k <= fmin(i+1,n); k++) {\n\t\t\t\t\t\t\tX(j-1,i-1) = X(j-1,i-1) + A(j-1,k-1)*X(k-1,i-1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// X(j-1,i-1) = -X(j-1,i-1)/(D(j-1,j-1)-D(i-1,i-1));\n\t\t\t\t\t\tif ((D(j-1,j-1)-D(i-1,i-1)).real()==0 && (D(j-1,j-1)-D(i-1,i-1)).imag()==0 && X(j-1,i-1).real()==0 && X(j-1,i-1).imag()==0) {\n\t\t\t\t\t\t\tX(j-1,i-1) = 0; // d(j) = d(i)\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tX(j-1,i-1) = -X(j-1,i-1)/(D(j-1,j-1)-D(i-1,i-1));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tj--;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tx = column(X,i-1);\n\t\t\tx_norm = 0;\n\t\t\tfor (k = 0; k < n; k++) {\n\t\t\t\tusing std::abs;\n\t\t\t\tx_norm += abs(x(k))*abs(x(k));\n\t\t\t}\n\t\t\tusing std::sqrt;\n\t\t\tx_norm = sqrt(x_norm);\n\t\t\tfor (k = 0; k < n; k++) {\n\t\t\t\tX(k,i-1) /= x_norm;\n\t\t\t}\n\t\t} else {\n\t\t\tfor (k = 0; k < n; k++) {\n\t\t\t\tX(k,i-1).real() = X(k,i-2).real();\n\t\t\t\tX(k,i-1).imag() = -X(k,i-2).imag();\n\t\t\t}\n\t\t\tflag = true;\n\t\t}\n\t}\n\t// V = P*X;\n\tV = prod(P,X);\n\n\treturn true;\n}\n\ntemplate bool eig(const ub::matrix& A, ub::matrix< kv::complex >& V, ub::matrix< kv::complex >& D)\n{\n\tint n = A.size1();\n\tif (n != A.size2()) return false;// Square matrix only\n\n\tub::matrix Q, H;\n\tQ.resize(n,n);\n\tH.resize(n,n);\n\n\t// std::cout << Q << \"\\n\";\n\thess(A,Q,H);\n\tfrancisQR(Q,H);\n\teig2by2(Q,H,V,D);\n\t// std::cout << \"Residual \" << prod(A,Q)-prod(Q,H) << \"\\n\";\n\t// std::cout << \"Residual \" << prod(A,V)-prod(V,D) << \"\\n\";\n\treturn true;\n}\n\ntemplate bool veig(const ub::matrix& A, ub::vector< kv::complex< kv::interval > >& v)\n{\n\tint i, j, n=A.size1();\n\tub::matrix< kv::complex > V, D;\n\tub::matrix< kv::complex< kv::interval > > X, C;\n\tub::matrix< kv::interval > BA, BC, G;\n\t// ub::vector< kv::complex< kv::interval > > b, x;\n\tub::vector< kv::interval > d, err;\n\n\teig(A,V,D);\n\t// std::cout << \"Residual \" << prod(a,V)-prod(V,D) << \"\\n\";\n\t// C = A*intval(X);\n\tX.resize(n,n);\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\tX(i,j) = V(i,j);\n\t\t}\n\t}\n\tC = prod(A,X);\n\n\t// G = verifylss(X,C);\n\tG.resize(2*n,n);\n\tBA.resize(2*n,2*n);\n\tBC.resize(2*n,n);\n\n\t// X = A + Bi;\n\t// BA = [A, -B; B, A]\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\tBA(i,j) = X(i,j).real();\n\t\t\tBA(i+n,j) = X(i,j).imag();\n\t\t\tBA(i,j+n) = -X(i,j).imag();\n\t\t\tBA(i+n,j+n) = X(i,j).real();\n\t\t}\n\t}\n\n\t// C = P + Qi\n\t// BC = [P;Q]\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\tBC(i,j) = C(i,j).real();\n\t\t\tBC(i+n,j) = C(i,j).imag();\n\t\t}\n\t}\n\tkv::vleq(BA,BC,G);\n\n\t// mid_G = mid(G);\n\n\td.resize(2*n);\n\terr.resize(2*n);\n\n\tfor (i = 0; i < n; i++) {\n\t\td(i) = mid(G(i,i));\n\t\td(i+n) = mid(G(i+n,i));\n\t\tG(i,i) -= d(i);\n\t\tG(i+n,i) -= d(i+n);\n\t}\n\n\t// G = G-mid_G;\n\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\terr(i) += G(i,j);\n\t\t\terr(i+n) += G(i+n,j);\n\t\t}\n\t}\n\n\tv.resize(n);\n\td += err;\n\tfor (i = 0; i < n; i++) {\n\t\tv(i) = kv::complex< kv::interval >(d(i),d(i+n));\n\t}\n\treturn true;\n}\n\ntemplate bool veig(const ub::matrix< kv::interval >& A, ub::vector< kv::complex< kv::interval > >& v)\n{\n\tint i, j, n=A.size1();\n\tub::matrix< kv::complex > V, D;\n\tub::matrix< kv::complex< kv::interval > > X, C;\n\tub::matrix< kv::interval > BA, BC, G;\n\t// ub::vector< kv::complex< kv::interval > > b, x;\n\tub::vector< kv::interval > d, err;\n\n\teig(mid(A),V,D);\n\t// std::cout << \"Residual \" << prod(a,V)-prod(V,D) << \"\\n\";\n\t// C = A*intval(X);\n\tX.resize(n,n);\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\tX(i,j) = V(i,j);\n\t\t}\n\t}\n\tC = prod(A,X);\n\n\t// G = verifylss(X,C);\n\tG.resize(2*n,n);\n\tBA.resize(2*n,2*n);\n\tBC.resize(2*n,n);\n\n\t// X = A + Bi;\n\t// BA = [A, -B; B, A]\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\tBA(i,j) = X(i,j).real();\n\t\t\tBA(i+n,j) = X(i,j).imag();\n\t\t\tBA(i,j+n) = -X(i,j).imag();\n\t\t\tBA(i+n,j+n) = X(i,j).real();\n\t\t}\n\t}\n\n\t// C = P + Qi\n\t// BC = [P;Q]\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\tBC(i,j) = C(i,j).real();\n\t\t\tBC(i+n,j) = C(i,j).imag();\n\t\t}\n\t}\n\tkv::vleq(BA,BC,G);\n\n\t// mid_G = mid(G);\n\n\td.resize(2*n);\n\terr.resize(2*n);\n\n\tfor (i = 0; i < n; i++) {\n\t\td(i) = mid(G(i,i));\n\t\td(i+n) = mid(G(i+n,i));\n\t\tG(i,i) -= d(i);\n\t\tG(i+n,i) -= d(i+n);\n\t}\n\n\t// G = G-mid_G;\n\n\tfor (i = 0; i < n; i++) {\n\t\tfor (j = 0; j < n; j++) {\n\t\t\terr(i) += G(i,j);\n\t\t\terr(i+n) += G(i+n,j);\n\t\t}\n\t}\n\n\tv.resize(n);\n\td += err;\n\tfor (i = 0; i < n; i++) {\n\t\tv(i) = kv::complex< kv::interval >(d(i),d(i+n));\n\t}\n\treturn true;\n}\n\ntemplate bool invert_comp(const ub::matrix >& A, ub::matrix >& R)\n{\n int n = A.size1();\n ub::matrix< kv::complex > LU=A;\n\n ub::vector< kv::complex > b(n);\n ub::vector pm(n);\n\n R.resize(n,n);\n\n lu_factorize_comp(LU,pm);\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j==i) b(j) = 1.0;\n else b(j) = 0.0;\n }\n // std::cout << \"b\" << b << std::endl;\n lu_substitute_comp(LU,pm,b);\n ub::column(R,i) = b;\n }\n return true;\n}\n\n} // namespace kv\n\n#endif // EIG_HPP\n", "meta": {"hexsha": "7119acc388a1863f1972bb5035d0bcf5f11c1357", "size": 16033, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "kv/eig.hpp", "max_stars_repo_name": "soonho-tri/kv", "max_stars_repo_head_hexsha": "4963be6560d8600cdc9ff22d004b2b965ae7b1df", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 67.0, "max_stars_repo_stars_event_min_datetime": "2017-01-04T15:30:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T05:45:02.000Z", "max_issues_repo_path": "src/interval/kv/eig.hpp", "max_issues_repo_name": "takafumihoriuchi/HyLaGI", "max_issues_repo_head_hexsha": "26b9f32a84611ee62d9cbbd903773d224088c959", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2017-02-10T02:59:45.000Z", "max_issues_repo_issues_event_max_datetime": "2019-10-10T14:17:08.000Z", "max_forks_repo_path": "src/interval/kv/eig.hpp", "max_forks_repo_name": "takafumihoriuchi/HyLaGI", "max_forks_repo_head_hexsha": "26b9f32a84611ee62d9cbbd903773d224088c959", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2021-09-29T02:27:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T05:45:04.000Z", "avg_line_length": 25.0907668232, "max_line_length": 171, "alphanum_fraction": 0.4661635377, "num_tokens": 6942, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711832583696, "lm_q2_score": 0.7057850154599562, "lm_q1q2_score": 0.5998969247165257}} {"text": "/*=================================================================================\n *\t Copyleft! 2018 William Yu\n * Some rights reserved：CC(creativecommons.org)BY-NC-SA\n * Copyleft! 2018 William Yu\n * 版权部分所有，遵循CC(creativecommons.org)BY-NC-SA协议授权方式使用\n *\n * Filename : \n * Description : 视觉SLAM十四讲/ch6/g2o 学习记录\n * Reference : \n * Programmer(s) : William Yu, windmillyucong@163.com\n * Company : HUST, DMET国家重点实验室FOCUS团队\n * Modification History\t : ver1.0, 2018.04.05, William Yu\n \n=================================================================================*/\n\n/// Include Files\n#include \n#include //定点类型\n#include //一元边类型\n#include //求解器\n#include //莱文贝格-马夸特方法 Levenberg-Marquardt算法\n#include //高斯牛顿法\n#include \n#include \n#include \n#include \n#include \n#include //计时库\nusing namespace std; \n\n\n\n/*-----------------------------[Note]---------------------------\n# G2O图优化\n深入理解图优化与g2o：图优化篇 http://www.cnblogs.com/gaoxiang12/p/5244828.html\n深入理解图优化与g2o：g2o篇 https://www.cnblogs.com/gaoxiang12/p/5304272.html\n--------------------------------------------------------------*/\n\n\n/// Global Variables\n\n/**\n * @class \n * @brief 待优化变量\n */\n// 曲线模型的顶点，模板参数：优化变量维度和数据类型\nclass CurveFittingVertex: public g2o::BaseVertex<3, Eigen::Vector3d>\n{\npublic:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n virtual void setToOriginImpl() // 重置\n {\n _estimate << 0,0,0;\n }\n \n virtual void oplusImpl( const double* update ) // 更新\n {\n _estimate += Eigen::Vector3d(update);\n }\n // 存盘和读盘：留空\n virtual bool read( istream& in ) {}\n virtual bool write( ostream& out ) const {}\n};\n\n\n\n\n\n\n\n\n/**\n * @class \n * @brief 误差模型\n */\n// 误差模型 模板参数：观测值维度，类型，连接顶点类型\nclass CurveFittingEdge: public g2o::BaseUnaryEdge<1,double,CurveFittingVertex>\n{\npublic:\n EIGEN_MAKE_ALIGNED_OPERATOR_NEW\n CurveFittingEdge( double x ): BaseUnaryEdge(), _x(x) {}\n // 计算曲线模型误差\n void computeError()\n {\n const CurveFittingVertex* v = static_cast (_vertices[0]);\n const Eigen::Vector3d abc = v->estimate();\n _error(0,0) = _measurement - std::exp( abc(0,0)*_x*_x + abc(1,0)*_x + abc(2,0) ) ;\n }\n virtual bool read( istream& in ) {}\n virtual bool write( ostream& out ) const {}\npublic:\n double _x; // x 值， y 值为 _measurement\n};\n\n\n\n\n\n\n\n\n/// Function Definitions\n\n/**\n * @function main\n * @author William Yu\n * @brief \n * @param None\n * @retval None\n */\nint main( int argc, char** argv )\n{\n double a=1.0, b=2.0, c=1.0; // 真实参数值\n int N=100; // 数据点\n double w_sigma=1.0; // 噪声Sigma值\n cv::RNG rng; // OpenCV随机数产生器\n double abc[3] = {0,0,0}; // abc参数的估计值\n\n vector x_data, y_data; // 数据\n \n cout<<\"generating data: \"< > Block; //误差项优化变量维度为3，误差值维度为1\n //线性求解器\n Block::LinearSolverType* linearSolver = new g2o::LinearSolverDense(); \n //稀疏矩阵求解\n Block* solver_ptr = new Block( linearSolver ); \n //迭代算法 从下面这三行 梯度下降方法，从高斯牛顿GN, 莱文贝格－马夸特方法LM, DogLeg中选择一个\n g2o::OptimizationAlgorithmLevenberg* solver = new g2o::OptimizationAlgorithmLevenberg( solver_ptr );\n // g2o::OptimizationAlgorithmGaussNewton* solver = new g2o::OptimizationAlgorithmGaussNewton( solver_ptr );\n // g2o::OptimizationAlgorithmDogleg* solver = new g2o::OptimizationAlgorithmDogleg( solver_ptr );\n //优化模型\n g2o::SparseOptimizer optimizer; \n optimizer.setAlgorithm( solver ); \n optimizer.setVerbose( true ); \n\n // //--[ERROR]see: https://www.cnblogs.com/xueyuanaichiyu/p/7921382.html\n // // 构建图优化，先设定g2o\n // typedef g2o::BlockSolver< g2o::BlockSolverTraits<3,1> > Block; // 每个误差项优化变量维度为3，误差值维度为1\n // Block::LinearSolverType* linearSolver = new g2o::LinearSolverDense(); // 线性方程求解器\n // Block* solver_ptr = new Block( std::unique_ptr(linearSolver) ); // 矩阵块求解器\n // // 梯度下降方法，从GN, LM, DogLeg 中选\n // g2o::OptimizationAlgorithmLevenberg* solver = new g2o::OptimizationAlgorithmLevenberg( std::unique_ptr(solver_ptr) );\n // // g2o::OptimizationAlgorithmGaussNewton* solver = new g2o::OptimizationAlgorithmGaussNewton( std::unique_ptr(solver_ptr) );\n // // g2o::OptimizationAlgorithmDogleg* solver = new g2o::OptimizationAlgorithmDogleg( std::unique_ptr(solver_ptr) );\n // g2o::SparseOptimizer optimizer; // 图模型\n // optimizer.setAlgorithm( solver ); // 设置求解器\n // optimizer.setVerbose( true ); // 打开调试输出\n \n // 往图中增加顶点\n CurveFittingVertex* v = new CurveFittingVertex();\n v->setEstimate( Eigen::Vector3d(0,0,0) );\n v->setId(0);\n optimizer.addVertex( v );\n \n // 往图中增加边\n for ( int i=0; isetId(i);\n edge->setVertex( 0, v ); // 设置连接的顶点\n edge->setMeasurement( y_data[i] ); // 观测数值\n edge->setInformation( Eigen::Matrix::Identity()*1/(w_sigma*w_sigma) ); // 信息矩阵：协方差矩阵之逆\n optimizer.addEdge( edge );\n }\n \n // 执行优化\n cout<<\"start optimization\"< time_used = chrono::duration_cast>( t2-t1 );\n cout<<\"solve time cost = \"<estimate();\n cout<<\"estimated model: \"<\n#include \n#include \n#include \n#include \n#include \n#include \n\n/////////////////////////////////////////////////////////////////////////////\n// Implementation when type A0 is arithmetic_\n/////////////////////////////////////////////////////////////////////////////\nnamespace nt2 { namespace ext\n{\n NT2_FUNCTOR_IMPLEMENTATION( nt2::tag::tchebeval_, tag::cpu_\n , (A0)(A1)\n , (scalar_< arithmetic_ >)(fusion_sequence_)\n )\n {\n\n typedef typename boost::dispatch::meta::as_floating::type result_type;\n\n NT2_FUNCTOR_CALL(2)\n {\n return tchebeval(result_type(a0), a1);\n }\n };\n} }\n\n\n/////////////////////////////////////////////////////////////////////////////\n// Implementation when type A0 is floating_\n/////////////////////////////////////////////////////////////////////////////\nnamespace nt2 { namespace ext\n{\n NT2_FUNCTOR_IMPLEMENTATION( nt2::tag::tchebeval_, tag::cpu_\n , (A0)(A1)\n , (scalar_< floating_ >)(fusion_sequence_)\n )\n {\n typedef A0 result_type;\n NT2_FUNCTOR_CALL(2)\n {\n typename A1::const_iterator p = a1.begin();\n A0 b0 = *p++;\n A0 b1 = Zero();\n A0 b2 = Zero();;\n while (p != a1.end())\n {\n b2 = -b1;\n b1 = b0;\n b0 = nt2::fma(a0, b1, b2+*p++);\n }\n return average(b0, b2);\n }\n };\n} }\n\n\n#endif\n", "meta": {"hexsha": "17af2d05ce530a7bad152838f3ff5ff0a26d1f47", "size": 2400, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "modules/core/polynomials/include/nt2/toolbox/polynomials/functions/scalar/tchebeval.hpp", "max_stars_repo_name": "timblechmann/nt2", "max_stars_repo_head_hexsha": "6c71f7063ca4e5975c9c019877e6b2fe07c9e4ce", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2016-09-14T00:23:53.000Z", "max_stars_repo_stars_event_max_datetime": "2018-01-14T12:51:18.000Z", "max_issues_repo_path": "modules/core/polynomials/include/nt2/toolbox/polynomials/functions/scalar/tchebeval.hpp", "max_issues_repo_name": "timblechmann/nt2", "max_issues_repo_head_hexsha": "6c71f7063ca4e5975c9c019877e6b2fe07c9e4ce", "max_issues_repo_licenses": ["BSL-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": "modules/core/polynomials/include/nt2/toolbox/polynomials/functions/scalar/tchebeval.hpp", "max_forks_repo_name": "timblechmann/nt2", "max_forks_repo_head_hexsha": "6c71f7063ca4e5975c9c019877e6b2fe07c9e4ce", "max_forks_repo_licenses": ["BSL-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": 34.2857142857, "max_line_length": 80, "alphanum_fraction": 0.485, "num_tokens": 541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789086703225, "lm_q2_score": 0.740174367770488, "lm_q1q2_score": 0.599895713816371}} {"text": "/**\n * @file QuadraticCost.cpp\n * @author Giulio Romualdi\n * @copyright Released under the terms of the MIT License.\n * @date 2021\n */\n\n#include \n\n#include \n\n#include \n#include \n\nusing namespace ScsEigen;\n\nQuadraticCost::QuadraticCost(const Eigen::Ref& Q,\n const Eigen::Ref& b,\n double c)\n : Cost((Q.rows() == Q.cols() && Q.rows() == b.rows()) ? Q.rows() : 0, \"Quadratic cost\")\n{\n if (Q.rows() != Q.cols() || Q.rows() != b.rows())\n {\n\n log()->error(\"[QuadraticCost::QuadraticCost] Q matrix must be square and the size of b \"\n \"should be coherent with Q\");\n assert(false);\n } else\n {\n m_Q = (Q + Q.transpose()) / 2;\n m_b = b;\n m_c = c;\n }\n}\n\nbool QuadraticCost::setQ(const Eigen::Ref& Q)\n{\n if (m_Q.size() != 0)\n {\n if (Q.size() != m_Q.size())\n {\n log()->error(\"[QuadraticCost::setQ] The size of the matrix 'Q' cannot change.\");\n return false;\n }\n } else if (Q.rows() != Q.cols())\n {\n log()->error(\"[QuadraticCost::QuadraticCost] Q matrix must be square.\");\n return false;\n } else if (!this->setNumberOfVariables(Q.rows()))\n {\n log()->error(\"[QuadraticCost::setQ] Unable to set the number of variables.\");\n return false;\n }\n\n m_Q = (Q + Q.transpose()) / 2;\n return true;\n}\n\nbool QuadraticCost::setB(const Eigen::Ref& b)\n{\n if (m_b.size() != 0)\n {\n if (b.size() != m_b.size())\n {\n log()->error(\"[QuadraticCost::setB] The size of the vector 'b' cannot change.\");\n return false;\n }\n } else if (!this->setNumberOfVariables(b.size()))\n {\n log()->error(\"[QuadraticCost::setB] Unable to set the number of variables.\");\n return false;\n }\n\n m_b = b;\n return true;\n}\n\nvoid QuadraticCost::setC(double c)\n{\n m_c = c;\n}\n\nEigen::Ref QuadraticCost::getB() const\n{\n return m_b;\n}\n\nEigen::Ref QuadraticCost::getQ() const\n{\n return m_Q;\n}\n\ndouble QuadraticCost::getC() const\n{\n return m_c;\n}\n", "meta": {"hexsha": "b64cadd8fba2d1221c0570fc85afc03a0566d687", "size": 2294, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/ScsEigen/src/QuadraticCost.cpp", "max_stars_repo_name": "GiulioRomualdi/scs-eigen", "max_stars_repo_head_hexsha": "b315dbee88f2a0bdcfe5b538607b858209880086", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-04-29T07:05:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-12T16:36:54.000Z", "max_issues_repo_path": "src/ScsEigen/src/QuadraticCost.cpp", "max_issues_repo_name": "GiulioRomualdi/scs-eigen", "max_issues_repo_head_hexsha": "b315dbee88f2a0bdcfe5b538607b858209880086", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-03T20:21:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-04T21:12:24.000Z", "max_forks_repo_path": "src/ScsEigen/src/QuadraticCost.cpp", "max_forks_repo_name": "GiulioRomualdi/scs-eigen", "max_forks_repo_head_hexsha": "b315dbee88f2a0bdcfe5b538607b858209880086", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-12-12T16:35:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-12T16:35:06.000Z", "avg_line_length": 23.6494845361, "max_line_length": 96, "alphanum_fraction": 0.5566695728, "num_tokens": 611, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257654, "lm_q2_score": 0.7401743505760728, "lm_q1q2_score": 0.5998957066572842}} {"text": "#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace bg = boost::geometry;\nusing tokenizer = boost::tokenizer>;\nusing point_t = bg::model::point>;\nusing polyline_t = bg::model::linestring;\n\nauto readFile() {\n polyline_t coordinates{};\n\n std::fstream coordinateFile;\n boost::char_separator sep{\",\"};\n coordinateFile.open(\"coordinates.csv\", std::ios::in);\n if(coordinateFile.is_open()) {\n std::string line;\n while(getline(coordinateFile, line)) {\n tokenizer tok{line, sep};\n std::vector vars {tok.begin(), tok.end()};\n point_t coord{boost::lexical_cast(vars[0]), boost::lexical_cast(vars[1])};\n bg::append(coordinates, coord);\n }\n }\n coordinateFile.close();\n return coordinates;\n}\n\ndouble ConvertToEarthRadiusProportion(const double distance) {\n constexpr double earth_radius = 6378140.0;\n return distance/earth_radius;\n}\n\nint main(int /*argc*/, char **/*argv[]*/) {\n std::cout << \"Douglas Peucker simplification algorithm application using Boost::Geometry\" << std::endl;\n polyline_t polyline = readFile();\n polyline_t decimated_polyline{};\n bg::strategy::simplify::douglas_peucker> douglas_peucker;\n bg::simplify(polyline, decimated_polyline, ConvertToEarthRadiusProportion(100.0), douglas_peucker);\n std::cout << \"Original Polyline Data Points: \" << polyline.size() <\n *\n * Copyright 2009 Marco Guazzone (marco.guazzone@gmail.com)\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\n#ifndef DCS_MATH_STATS_DISTRIBUTION_STUDENTS_T_HPP\n#define DCS_MATH_STATS_DISTRIBUTION_STUDENTS_T_HPP\n\n\n#include \n\n#if !DCS_DETAIL_CONFIG_BOOST_CHECK_VERSION(103500) // 1.35\n# \terror \"Required Boost library version >= 1.35\"\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nnamespace dcs { namespace math { namespace stats {\n\nusing ::std::size_t;\n\n\n/**\n * \\brief The Student's t distribution with parameter \\f$\\nu\\f$ (the degrees of\n * freedom).\n *\n * \\tparam RealT The type used for real numbers.\n * \\tparam PolicyT The policy type.\n *\n * \\author Marco Guazzone (marco.guazzone@gmail.com)\n */\ntemplate < typename RealT=double, typename PolicyT=::dcs::math::policies::policy<> >\nclass students_t_distribution\n{\n\tpublic: typedef RealT support_type;\n\tpublic: typedef RealT value_type;\n\tpublic: typedef PolicyT policy_type;\n\n\tpublic: explicit students_t_distribution(support_type df)\n\t\t: dist_(df)\n\t{\n\t\t// empty\n\t}\n\n\n\t// compiler-generated copy ctor and assignment operator are fine\n\n\n\t/**\n\t * \\brief Generate a vector of random numbers distributed according to this\n\t * Student's t distribution.\n\t *\n\t * \\param rng A uniform random number generator.\n\t * \\param n The number of random numbers to generate.\n\t * \\return A random number distributed according to this Student's t\n\t * distribution.\n\t *\n\t * A \\c Student's t random number distribution produces random numbers * \\f$x\\f$\n\t * distributed according to the probability density function:\n\t * \\f[\n\t * \\frac{\\Gamma(\\frac{\\nu+1}{2})} {\\sqrt{\\nu\\pi}\\,\\Gamma(\\frac{\\nu}{2})} \\left(1+\\frac{x^2}{\\nu} \\right)^{-(\\frac{\\nu+1}{2})}\n\t * \\f]\n\t */\n\tpublic: template \n\t\tsupport_type rand(UniformRandomGeneratorT& rng) const\n\t{\n\t\tnormal_distribution norm;\n\t\tchi_squared_distribution chi(dist_.degrees_of_freedom());\n\t\treturn\t::dcs::math::stats::rand(norm, rng)\n\t\t\t\t/ ::std::sqrt(\n\t\t\t\t\t\t::dcs::math::stats::rand(chi, rng)\n\t\t\t\t\t\t/ dist_.degrees_of_freedom()\n\t\t\t\t\t);\n\t}\n\n\n\t/**\n\t * \\brief Generate a vector of random numbers distributed according to this\n\t * normal distribution.\n\t *\n\t * \\param rng A uniform random number generator.\n\t * \\param n The number of random numbers to generate.\n\t * \\return A vector of random numbers distributed according to this\n\t * normal distribution.\n\t *\n\t * A \\c normal random number distribution produces random numbers * \\f$x\\f$\n\t * distributed according to the probability density function:\n\t * \\f[\n\t * \\Pr(x|\\mu,\\sigma) = \\frac{1}{\\sigma\\sqrt{2\\pi}}\\exp\\left(-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right)\n\t * \\f]\n\t */\n\tpublic: template \n\t\t::std::vector rand(UniformRandomGeneratorT& rng, size_t n)\n\t{\n\t\t::std::vector rnds(n);\n\n\t\tfor ( ; n > 0; --n)\n\t\t{\n\t\t\trnds.push_back(rand(rng));\n\t\t}\n\n\t\treturn rnds;\n\t}\n//@}TODO\n\n\n\tpublic: support_type degrees_of_freedom() const\n\t{\n\t\treturn dist_.degrees_of_freedom();\n\t}\n\n\n\tpublic: support_type location() const\n\t{\n\t\treturn support_type(0);\n\t}\n\n\n\tpublic: support_type scale() const\n\t{\n\t\treturn support_type(1);\n\t}\n\n\n\tpublic: support_type quantile(value_type p) const\n\t{\n\t\treturn ::boost::math::quantile(dist_, p);\n\t}\n\n\n\tprivate: ::boost::math::students_t_distribution dist_;\n};\n\n\ntemplate <\n typename CharT,\n typename CharTraitsT,\n typename RealT,\n typename PolicyT\n>\n::std::basic_ostream& operator<<(::std::basic_ostream& os, students_t_distribution const& dist)\n{\n return os << \"StudentT(\"\n << \"df=\" << dist.degrees_of_freedom()\n << \")\";\n}\n\n}}} // Namespace dcs::math::stats\n\n#endif // DCS_MATH_STATS_DISTRIBUTION_STUDENTS_T_HPP\n", "meta": {"hexsha": "d7354047db1599714ede95567d3fe61927b93476", "size": 4770, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "inc/dcs/math/stats/distribution/students_t.hpp", "max_stars_repo_name": "sguazt/dcsxx-commons", "max_stars_repo_head_hexsha": "0fc1fd8a38b7c412941b401c00a9293bc5df8b21", "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": "inc/dcs/math/stats/distribution/students_t.hpp", "max_issues_repo_name": "sguazt/dcsxx-commons", "max_issues_repo_head_hexsha": "0fc1fd8a38b7c412941b401c00a9293bc5df8b21", "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": "inc/dcs/math/stats/distribution/students_t.hpp", "max_forks_repo_name": "sguazt/dcsxx-commons", "max_forks_repo_head_hexsha": "0fc1fd8a38b7c412941b401c00a9293bc5df8b21", "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.6480446927, "max_line_length": 148, "alphanum_fraction": 0.7073375262, "num_tokens": 1272, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.857768108626046, "lm_q2_score": 0.6992544273261176, "lm_q1q2_score": 0.5997981475759129}} {"text": "/**\n * \\file TanFilter.cpp\n */\n\n#include \"TanFilter.h\"\n\n#include \n#include \n\n#include \n\nnamespace ATK\n{\n template\n TanFilter::TanFilter(int nb_channels)\n :Parent(nb_channels, nb_channels), coeff(1)\n {\n \n }\n \n template\n TanFilter::~TanFilter()\n {\n \n }\n \n template\n void TanFilter::setup()\n {\n coeff = boost::math::constants::pi() / input_sampling_rate;\n }\n \n template\n void TanFilter::process_impl(int64_t size) const\n {\n for(int channel = 0; channel < nb_input_ports; ++channel)\n {\n const DataType* ATK_RESTRICT input = converted_inputs[channel];\n DataType* ATK_RESTRICT output = outputs[channel];\n for(int64_t i = 0; i < size; ++i)\n {\n *(output++) = static_cast(tan(*(input++) * coeff));\n }\n }\n }\n \n template class TanFilter;\n template class TanFilter;\n}\n", "meta": {"hexsha": "a0c3c224a17a4ecd4cae05f45c0c095c386c78ae", "size": 1041, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "ATK/Tools/TanFilter.cpp", "max_stars_repo_name": "apohl79/AudioTK", "max_stars_repo_head_hexsha": "05ac241b0bc6a8f841d93257b4d81e5961b1f627", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2018-05-17T15:29:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-19T22:26:08.000Z", "max_issues_repo_path": "ATK/Tools/TanFilter.cpp", "max_issues_repo_name": "apohl79/AudioTK", "max_issues_repo_head_hexsha": "05ac241b0bc6a8f841d93257b4d81e5961b1f627", "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": "ATK/Tools/TanFilter.cpp", "max_forks_repo_name": "apohl79/AudioTK", "max_forks_repo_head_hexsha": "05ac241b0bc6a8f841d93257b4d81e5961b1f627", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-04-21T13:43:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-28T19:10:14.000Z", "avg_line_length": 20.82, "max_line_length": 74, "alphanum_fraction": 0.6589817483, "num_tokens": 262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681195338728, "lm_q2_score": 0.6992544085240401, "lm_q1q2_score": 0.5997981390754363}} {"text": "#include \"incidencematrices.h\"\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\nnamespace IncidenceMatrices {\n\n/** @brief Create the mesh consisting of a triangle and quadrilateral\n * from the exercise sheet.\n * @return Shared pointer to the hybrid2d mesh.\n */\nstd::shared_ptr createDemoMesh() {\n // builder for a hybrid mesh in a world of dimension 2\n std::shared_ptr mesh_factory_ptr =\n std::make_shared(2);\n\n // Add points\n mesh_factory_ptr->AddPoint(Eigen::Vector2d{0, 0}); // (0)\n mesh_factory_ptr->AddPoint(Eigen::Vector2d{1, 0}); // (1)\n mesh_factory_ptr->AddPoint(Eigen::Vector2d{1, 1}); // (2)\n mesh_factory_ptr->AddPoint(Eigen::Vector2d{0, 1}); // (3)\n mesh_factory_ptr->AddPoint(Eigen::Vector2d{0.5, 1}); // (4)\n\n // Add the triangle\n // First set the coordinates of its nodes:\n Eigen::MatrixXd nodesOfTria(2, 3);\n nodesOfTria << 1, 1, 0.5, 0, 1, 1;\n mesh_factory_ptr->AddEntity(\n lf::base::RefEl::kTria(), // we want a triangle\n std::array{\n {1, 2, 4}}, // indices of the nodes\n std::make_unique(nodesOfTria)); // node coords\n\n // Add the quadrilateral\n Eigen::MatrixXd nodesOfQuad(2, 4);\n nodesOfQuad << 0, 1, 0.5, 0, 0, 0, 1, 1;\n mesh_factory_ptr->AddEntity(\n lf::base::RefEl::kQuad(),\n std::array{{0, 1, 4, 3}},\n std::make_unique(nodesOfQuad));\n\n std::shared_ptr demoMesh_p = mesh_factory_ptr->Build();\n\n return demoMesh_p;\n}\n\n/** @brief Compute the edge-vertex incidence matrix G for a given mesh\n * @param mesh The input mesh of type lf::mesh::Mesh (or of derived type,\n * such as lf::mesh::hybrid2d::Mesh)\n * @return The edge-vertex incidence matrix as Eigen::SparseMatrix\n */\n/* SAM_LISTING_BEGIN_1 */\nEigen::SparseMatrix computeEdgeVertexIncidenceMatrix(\n const lf::mesh::Mesh &mesh) {\n // Store edge-vertex incidence matrix here\n Eigen::SparseMatrix G;\n\n#if SOLUTION\n // Mesh::NumEntities(unsigned codim) returns the number of elements\n // with given codimension. Codim(Edge) = 1, Codim(Node) = 2.\n const lf::mesh::Mesh::size_type numEdges = mesh.NumEntities(1),\n numNodes = mesh.NumEntities(2);\n // Following the demo for the reserve()-initialising the sparse matrix given\n // in the exercise sheet. From (2.1a) we know that G has exactly 2 entries\n // per row.\n G = Eigen::SparseMatrix(numEdges, numNodes);\n G.reserve(Eigen::VectorXi::Constant(numEdges, 2));\n\n // To compute G efficiently we iterate over all edges and check the index\n // of the nodes at its end. This is the efficient way to do the assembly,\n // introduced as \"distribute scheme\" in class. We cannot iterative over\n // vertices, because LehrFEM++ does not allow to visit the edges\n // adjacent to a vertex\n for (const lf::mesh::Entity *edge : mesh.Entities(1)) {\n // Get index of this edge\n lf::mesh::Mesh::size_type edgeIdx = mesh.Index(*edge);\n // Get the nodes and their indices.\n // Note, that seen from the edges the nodes have codim 1, not 2,\n // hence we call SubEntities(1). This is a relative codimension!\n auto nodes = edge->SubEntities(1);\n lf::mesh::Mesh::size_type firstNodeIdx = mesh.Index(*nodes[0]);\n lf::mesh::Mesh::size_type lastNodeIdx = mesh.Index(*nodes[1]);\n // Add the matrix entries according to the definition\n G.coeffRef(edgeIdx, firstNodeIdx) += 1;\n G.coeffRef(edgeIdx, lastNodeIdx) -= 1;\n }\n#else\n //====================\n // Your code goes here\n //====================\n#endif\n\n return G;\n}\n/* SAM_LISTING_END_1 */\n\n/** @brief Compute the cell-edge incidence matrix D for a given mesh\n * @param mesh The input mesh of type lf::mesh::Mesh (or of derived type,\n * such as lf::mesh::hybrid2d::Mesh)\n * @return The cell-edge incidence matrix as Eigen::SparseMatrix\n */\n/* SAM_LISTING_BEGIN_2 */\nEigen::SparseMatrix computeCellEdgeIncidenceMatrix(\n const lf::mesh::Mesh &mesh) {\n // Store cell-edge incidence matrix here\n Eigen::SparseMatrix D;\n\n#if SOLUTION\n // Mesh::NumEntities(unsigned codim) returns the number of elements\n // with given codimension. Codim(Edge) = 0, Codim(Node) = 1.\n const lf::mesh::Mesh::size_type numCells = mesh.NumEntities(0),\n numEdges = mesh.NumEntities(1);\n // Following the demo for the reserve()-initialising the sparse matrix given\n // in the exercise sheet. From (2.1a) we know that D has at most 4 entries\n // per row.\n D = Eigen::SparseMatrix(numCells, numEdges);\n D.reserve(Eigen::VectorXi::Constant(numCells, 4));\n\n // To compute D efficiently we iterate over all cells and check the\n // orientations (+1 or -1, same as in the definition of the matrix D)\n // of its edges. For this we may use RelativeOrientations().\n for (const lf::mesh::Entity *cell : mesh.Entities(0)) {\n // Get cell index\n lf::mesh::Mesh::size_type cellIdx = mesh.Index(*cell);\n // Get edges and their orientations (these already the entries for D!)\n auto edges = cell->SubEntities(1);\n auto edgeOrientations = cell->RelativeOrientations();\n\n // Iterate over both and add to D\n auto edgeIt = edges.begin();\n auto orntIt = edgeOrientations.begin();\n for (; edgeIt != edges.end() && orntIt != edgeOrientations.end();\n ++edgeIt, ++orntIt) {\n // Get the edge index and add its orientation to D\n lf::mesh::Mesh::size_type edgeIdx = mesh.Index(**edgeIt);\n D.coeffRef(cellIdx, edgeIdx) += lf::mesh::to_sign(*orntIt);\n }\n }\n#else\n //====================\n // Your code goes here\n //====================\n#endif\n\n return D;\n}\n/* SAM_LISTING_END_2 */\n\n/** @brief For a given mesh test if the product of cell-edge and edge-vertex\n * incidence matrix is zero: D*G == 0?\n * @param mesh The input mesh of type lf::mesh::Mesh (or of derived type,\n * such as lf::mesh::hybrid2d::Mesh)\n * @return true, if the product is zero and false otherwise\n */\n/* SAM_LISTING_BEGIN_3 */\nbool testZeroIncidenceMatrixProduct(const lf::mesh::Mesh &mesh) {\n bool isZero = false;\n\n#if SOLUTION\n Eigen::SparseMatrix G = computeEdgeVertexIncidenceMatrix(mesh),\n D = computeCellEdgeIncidenceMatrix(mesh);\n\n Eigen::SparseMatrix O = D * G;\n // Possibility 1:\n // Not prone to roundoff errors, since O is an integer matrix!\n isZero = O.norm() == 0;\n // Possibility 2: But this doesn't use the fact that O is sparse.\n // isZero = Eigen::MatrixXi(O).isZero(0);\n#else\n //====================\n // Your code goes here\n //====================\n#endif\n return isZero;\n}\n/* SAM_LISTING_END_3 */\n\n} // namespace IncidenceMatrices\n", "meta": {"hexsha": "f37241ed01455d3e9f8f65ed12cd4b8f99d8c740", "size": 7043, "ext": "cc", "lang": "C++", "max_stars_repo_path": "developers/IncidenceMatrices/mastersolution/incidencematrices.cc", "max_stars_repo_name": "padomu/NPDECODES", "max_stars_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15.0, "max_stars_repo_stars_event_min_datetime": "2019-04-29T11:28:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T05:10:58.000Z", "max_issues_repo_path": "developers/IncidenceMatrices/mastersolution/incidencematrices.cc", "max_issues_repo_name": "padomu/NPDECODES", "max_issues_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-02-29T15:05:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-21T13:51:07.000Z", "max_forks_repo_path": "developers/IncidenceMatrices/mastersolution/incidencematrices.cc", "max_forks_repo_name": "padomu/NPDECODES", "max_forks_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 26.0, "max_forks_repo_forks_event_min_datetime": "2020-01-09T15:59:23.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T16:27:33.000Z", "avg_line_length": 37.8655913978, "max_line_length": 78, "alphanum_fraction": 0.6606559705, "num_tokens": 1991, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7090191337850933, "lm_q2_score": 0.8459424314825853, "lm_q1q2_score": 0.5997893700018383}} {"text": "///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\file formic/utils/numeric.cpp\n///\n/// \\brief implementation file for miscellaneous functions related to numbers\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\n\n#include \"numeric.h\"\n#include \"formic/utils/mpi_interface.h\"\n\n#include \n#include \n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief get an offset array used in compounding pairs of distinct indices\n///\n/// For two indices i,j with i < j, we have: compound(i,j) = i + ioff[j];\n///\n/// \\param[in] n desired length of the array\n/// \\param[in,out] ioff on exit, the offset array\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nvoid formic::get_pair_ioff(int n, std::vector & ioff) {\n\n if (ioff.size() != n)\n ioff.resize(n);\n\n if ( n <= 0 )\n return;\n\n ioff.at(0) = 0;\n for (int i = 1; i < n; i++)\n ioff.at(i) = ioff.at(i-1) + i - 1;\n\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief computes the binomial coefficient\n///\n/// \\param[in] n number of things\n/// \\param[in] m how many things to take at a time\n///\n/// \\return the number of ways n things can be taken m at a time\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nint formic::binom_coeff(int n, int m) {\n if (n < 0 || m < 0 || m > n) return 0;\n double retval = 1.0;\n while (m > 0) retval = ( retval * (n--) ) / (m--);\n return int(retval+0.5);\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief Returns the number of solutions to the equation\n/// x(1) + x(2) + ... + x(n) = r\n/// when the variables x(i) are constrained to be\n/// integers in the range (0, 1, 2, ..., k)\n///\n/// \\param[in] n number of variables\n/// \\param[in] r sum of variables\n/// \\param[in] k range of each variable\n/// \\param[out] work integer workspace, either null or size >= k+1\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nint formic::n_integer_solutions(const int n, const int r, const int k, int * work) {\n\n assert( n >= 0 );\n assert( r >= 0 );\n assert( k >= 0 );\n\n // if requested, dynamically allocate the work space\n boost::scoped_array dynamic_work;\n if (work == 0) {\n dynamic_work.reset( new int[k+1] );\n work = dynamic_work.get();\n }\n\n // initialize an array to hold the number of variables having each allowed value\n int * const n_with_value = work;\n work += (k+1);\n for (int i = 0; i <= k; i++)\n n_with_value[i] = 0;\n\n // initialize the return value\n int retval = 0;\n\n // Loop over all possible distributions of variables among the values.\n // Note that we do not directly track of how many variables are equal to zero,\n // as this is known by how many variables take on other values.\n while (true) {\n\n // compute the number of nonzero variables\n int n_nonzero = 0;\n for (int i = 1; i <= k; i++)\n n_nonzero += n_with_value[i];\n\n // compute the sum of the variables\n int sum = 0;\n for (int i = 1; i <= k; i++)\n sum += i * n_with_value[i];\n\n // if this distribution solves the equation, count how many ways it can occur\n if (sum == r && n_nonzero <= n) {\n\n // determine how many variables are nonzero\n int t = 0;\n for (int i = 1; i <= k; i++)\n t += n_with_value[i];\n\n // count how many ways the variables can satisfy this distribution\n int occurrences = formic::binom_coeff(n, t);\n for (int i = 1; i < k; i++) {\n occurrences *= formic::binom_coeff(t, n_with_value[i]);\n t -= n_with_value[i]; // t is now equal to the number of variables greater than i\n }\n\n // record how many ways the variables satisfy this distribution\n retval += occurrences;\n\n }\n\n // increment to the next distribution of variables\n int p;\n for (p = k; p > 0; p--)\n if (++n_with_value[p] > n)\n n_with_value[p] = 0;\n else\n break;\n\n // stop iterating if all distributions have been processed\n if (p == 0) break;\n\n }\n\n // return the result\n return retval;\n\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief formats a real number into a string\n///\n/// \\param[in] f the formatting string used by boost::format\n/// \\param[in] value the number to be formatted\n///\n/// \\return the string containing the formatted number\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nstd::string formic::format_number(const std::string & f, const double value) {\n return (boost::format(f) % value).str();\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief formats a complex number into a string\n///\n/// \\param[in] f the formatting string used by boost::format\n/// \\param[in] value the number to be formatted\n///\n/// \\return the string containing the formatted number\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nstd::string formic::format_number(const std::string & f, const std::complex value) {\n std::string retval;\n retval.append(\"( \");\n retval.append( (boost::format(f) % value.real()).str() );\n retval.append(\", \");\n retval.append( (boost::format(f) % value.imag()).str() );\n retval.append(\" )\");\n return retval;\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief computes the unbiased estimate of a ratio of means: _p / _p in which the\n/// numerator and denominator values are sampled from the same probability distribution p\n///\n/// \\param[in] n the number of samples\n/// \\param[in] p the probability weight for each sample\n/// \\param[in] f the numerator samples\n/// \\param[in] g the denominator samples\n/// \\param[out] r on exit, the estimate of the ratio _p / _p\n/// \\param[out] v on exit, the estimate of the variance in the ratio\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nvoid formic::unbiased_ratio_of_means(const int n, const double * const p, const double * const f, const double * const g, double & r, double & v) {\n\n // compute the normalization, the numerator and denominator means, the means of the squares, and the mean of the products\n double nm = 0.0; // normalization constant\n double mf = 0.0; // mean of numerator\n double mg = 0.0; // mean of denominator\n double sf = 0.0; // mean of the square of the numerator terms\n double sg = 0.0; // mean of the square of the denominator terms\n double mp = 0.0; // mean of the product of numerator times denominator\n for (int i = 0; i < n; i++) {\n nm += p[i];\n double x = p[i] * f[i];\n mf += x;\n sf += x * f[i];\n mp += x * g[i];\n x = p[i] * g[i];\n mg += x;\n sg += x * g[i];\n }\n mf /= nm;\n mg /= nm;\n sf /= nm;\n sg /= nm;\n mp /= nm;\n\n // compute the numerator and denominator variances and the covariance\n const double vf = ( sf - mf * mf ) * double(n) / double(n-1);\n const double vg = ( sg - mg * mg ) * double(n) / double(n-1);\n const double cv = ( mp - mf * mg ) * double(n) / double(n-1);\n\n // compute the unbiased estimate of the ratio of means\n r = ( mf / mg ) / ( 1.0 + ( vg / mg / mg - cv / mf / mg ) / double(n) );\n\n // compute the unbiased estimate of the variance of the ratio of means\n v = ( mf * mf / mg / mg / double(n) ) * ( vf / mf / mf + vg / mg / mg - 2.0 * cv / mf / mg );\n\n}\n\n///////////////////////////////////////////////////////////////////////////////////////////////////\n/// \\brief computes the unbiased estimate of a ratio of means: _p / _p in which the\n/// numerator and denominator values are sampled from the same probability distribution p\n/// and samples are combined across all processors\n///\n/// \\param[in] n the number of samples on this process\n/// \\param[in] p the probability weight for each sample\n/// \\param[in] f the numerator samples\n/// \\param[in] g the denominator samples\n/// \\param[out] r on exit, the estimate of the ratio _p / _p\n/// \\param[out] v on exit, the estimate of the variance in the ratio\n///\n///////////////////////////////////////////////////////////////////////////////////////////////////\nvoid formic::mpi_unbiased_ratio_of_means(const int n, const double * const p, const double * const f, const double * const g, double & r, double & v) {\n\n // compute the normalization, the numerator and denominator means, the means of the squares, and the mean of the products\n double y[7];\n y[0] = 0.0; // normalization constant\n y[1] = 0.0; // mean of numerator\n y[2] = 0.0; // mean of denominator\n y[3] = 0.0; // mean of the square of the numerator terms\n y[4] = 0.0; // mean of the square of the denominator terms\n y[5] = 0.0; // mean of the product of numerator times denominator\n y[6] = double(n); // number of samples\n for (int i = 0; i < n; i++) {\n y[0] += p[i];\n double x = p[i] * f[i];\n y[1] += x;\n y[3] += x * f[i];\n y[5] += x * g[i];\n x = p[i] * g[i];\n y[2] += x;\n y[4] += x * g[i];\n }\n double z[7];\n formic::mpi::allreduce(&y[0], &z[0], 7, MPI_SUM);\n const double mf = z[1] / z[0]; // mean of numerator\n const double mg = z[2] / z[0]; // mean of denominator\n const double sf = z[3] / z[0]; // mean of the square of the numerator terms\n const double sg = z[4] / z[0]; // mean of the square of the denominator terms\n const double mp = z[5] / z[0]; // mean of the product of numerator times denominator\n const double ns = z[6]; // number of samples\n\n // compute the numerator and denominator variances and the covariance\n const double vf = ( sf - mf * mf ) * ns / ( ns - 1.0 );\n const double vg = ( sg - mg * mg ) * ns / ( ns - 1.0 );\n const double cv = ( mp - mf * mg ) * ns / ( ns - 1.0 );\n\n // compute the unbiased estimate of the ratio of means\n r = ( mf / mg ) / ( 1.0 + ( vg / mg / mg - cv / mf / mg ) / ns );\n\n // compute the unbiased estimate of the variance of the ratio of means\n v = ( mf * mf / mg / mg ) * ( vf / mf / mf + vg / mg / mg - 2.0 * cv / mf / mg );\n\n}\n", "meta": {"hexsha": "049012874b5c0ed79eb3bc2ab7d38447b3026926", "size": 10736, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/formic/utils/numeric.cpp", "max_stars_repo_name": "eugeneswalker/qmcpack", "max_stars_repo_head_hexsha": "352ff27f163bb92e0c232c48bec8ae7951ed9d8c", "max_stars_repo_licenses": ["NCSA"], "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/formic/utils/numeric.cpp", "max_issues_repo_name": "eugeneswalker/qmcpack", "max_issues_repo_head_hexsha": "352ff27f163bb92e0c232c48bec8ae7951ed9d8c", "max_issues_repo_licenses": ["NCSA"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2020-05-09T20:57:21.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-10T00:00:17.000Z", "max_forks_repo_path": "src/formic/utils/numeric.cpp", "max_forks_repo_name": "williamfgc/qmcpack", "max_forks_repo_head_hexsha": "732b473841e7823a21ab55ff397eed059f0f2e96", "max_forks_repo_licenses": ["NCSA"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.7581227437, "max_line_length": 151, "alphanum_fraction": 0.506147541, "num_tokens": 2693, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.7490872187162396, "lm_q1q2_score": 0.5997881448983959}} {"text": "/**\n * @file mean_shift.hpp\n * @author Shangtong Zhang\n *\n * Mean Shift clustering\n */\n\n#ifndef MLPACK_METHODS_MEAN_SHIFT_MEAN_SHIFT_HPP\n#define MLPACK_METHODS_MEAN_SHIFT_MEAN_SHIFT_HPP\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace mlpack {\nnamespace meanshift /** Mean shift clustering. */ {\n\n/**\n * This class implements mean shift clustering. For each point in dataset,\n * apply mean shift algorithm until maximum iterations or convergence. Then\n * remove duplicate centroids.\n *\n * A simple example of how to run mean shift clustering is shown below.\n *\n * @code\n * extern arma::mat data; // Dataset we want to run mean shift on.\n * arma::Col assignments; // Cluster assignments.\n * arma::mat centroids; // Cluster centroids.\n *\n * MeanShift<> meanShift();\n * meanShift.Cluster(dataset, assignments, centroids);\n * @endcode\n *\n * @tparam UseKernel Use kernel or mean to calculate new centroid.\n * If false, KernelType will be ignored.\n * @tparam KernelType The kernel to use.\n * @tparam MatType The type of matrix the data is stored in.\n */\ntemplate\nclass MeanShift\n{\n public:\n /**\n * Create a mean shift object and set the parameters which mean shift will be\n * run with.\n *\n * @param radius If distance of two centroids is less than it, one will be\n * removed. If this value isn't positive, an estimation will be given\n * when clustering.\n * @param maxIterations Maximum number of iterations allowed before giving up\n * iterations will terminate.\n * @param kernel Optional KernelType object.\n */\n MeanShift(const double radius = 0,\n const size_t maxIterations = 1000,\n const KernelType kernel = KernelType());\n\n /**\n * Give an estimation of radius based on given dataset.\n *\n * @param data Dataset for estimation.\n * @param ratio Percentage of dataset to use for nearest neighbor search.\n */\n double EstimateRadius(const MatType& data, const double ratio = 0.2);\n\n /**\n * Perform mean shift clustering on the data, returning a list of cluster\n * assignments and centroids.\n *\n * @tparam MatType Type of matrix.\n * @param data Dataset to cluster.\n * @param assignments Vector to store cluster assignments in.\n * @param centroids Matrix in which centroids are stored.\n */\n void Cluster(const MatType& data,\n arma::Col& assignments,\n arma::mat& centroids,\n bool useSeeds = true);\n\n //! Get the maximum number of iterations.\n size_t MaxIterations() const { return maxIterations; }\n //! Set the maximum number of iterations.\n size_t& MaxIterations() { return maxIterations; }\n\n //! Get the radius.\n double Radius() const { return radius; }\n //! Set the radius.\n void Radius(double radius);\n\n //! Get the kernel.\n const KernelType& Kernel() const { return kernel; }\n //! Modify the kernel.\n KernelType& Kernel() { return kernel; }\n\n private:\n /**\n * To speed up, we can generate some seeds from data set and use\n * them as initial centroids rather than all the points in the data set. The\n * basic idea here is that we will place our points into hypercube bins of\n * side length binSize, and any bins that contain fewer than minFreq points\n * will be removed as possible seeds. Usually, 1 is a sufficient parameter\n * for minFreq, and the bin size can be set equal to the estimated radius.\n *\n * @param data The reference data set.\n * @param binSize Width of hypercube bins.\n * @param minFreq Minimum number of points in bin.\n * @param seed Matrix to store generated seeds in.\n */\n void GenSeeds(const MatType& data,\n const double binSize,\n const int minFreq,\n MatType& seeds);\n\n /**\n * Use kernel to calculate new centroid given dataset and valid neighbors.\n *\n * @param data The whole dataset\n * @param neighbors Valid neighbors\n * @param distances Distances to neighbors\n # @param centroid Store calculated centroid\n */\n template\n typename std::enable_if::type\n CalculateCentroid(const MatType& data,\n const std::vector& neighbors,\n const std::vector& distances,\n arma::colvec& centroid);\n\n /**\n * Use mean to calculate new centroid given dataset and valid neighbors.\n *\n * @param data The whole dataset\n * @param neighbors Valid neighbors\n * @param distances Distances to neighbors\n # @param centroid Store calculated centroid\n */\n template\n typename std::enable_if::type\n CalculateCentroid(const MatType& data,\n const std::vector& neighbors,\n const std::vector&, /*unused*/\n arma::colvec& centroid);\n\n /**\n * If distance of two centroids is less than radius, one will be removed.\n * Points with distance to current centroid less than radius will be used\n * to calculate new centroid.\n */\n double radius;\n\n //! Maximum number of iterations before giving up.\n size_t maxIterations;\n\n //! Instantiated kernel.\n KernelType kernel;\n};\n\n} // namespace meanshift\n} // namespace mlpack\n\n// Include implementation.\n#include \"mean_shift_impl.hpp\"\n\n#endif // MLPACK_METHODS_MEAN_SHIFT_MEAN_SHIFT_HPP\n", "meta": {"hexsha": "d7607d0f0f7f7acd64935bfd7520a34b4f59dd94", "size": 5614, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/mlpack/methods/mean_shift/mean_shift.hpp", "max_stars_repo_name": "jmlevin7878/mlpack", "max_stars_repo_head_hexsha": "7fe38005d86b77293f728c34ca176224bdff9ee8", "max_stars_repo_licenses": ["BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-08-17T11:59:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-17T11:59:12.000Z", "max_issues_repo_path": "src/mlpack/methods/mean_shift/mean_shift.hpp", "max_issues_repo_name": "jmlevin7878/mlpack", "max_issues_repo_head_hexsha": "7fe38005d86b77293f728c34ca176224bdff9ee8", "max_issues_repo_licenses": ["BSD-3-Clause-No-Nuclear-License-2014", "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/mlpack/methods/mean_shift/mean_shift.hpp", "max_forks_repo_name": "jmlevin7878/mlpack", "max_forks_repo_head_hexsha": "7fe38005d86b77293f728c34ca176224bdff9ee8", "max_forks_repo_licenses": ["BSD-3-Clause-No-Nuclear-License-2014", "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": 33.2189349112, "max_line_length": 79, "alphanum_fraction": 0.6864980406, "num_tokens": 1261, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256631249077, "lm_q2_score": 0.7122321964553657, "lm_q1q2_score": 0.5995753410799478}} {"text": "#include \"TriMesh.h\"\n#include \n\nnamespace geomlib {\nTriMesh::TriMesh(const Eigen::MatrixXf& vertices, const Eigen::MatrixXi& faces)\n : vertices_{vertices}, faces_{faces} {}\n\nconst Eigen::MatrixXf& TriMesh::GetVertexNormals() const {\n if (!vertex_normals_) {\n CalculateVertexNormals();\n }\n return *vertex_normals_;\n}\n\nconst Eigen::MatrixXf& TriMesh::GetFaceNormals() const {\n if (!face_normals_) {\n CalculateFaceNormals();\n }\n return *face_normals_;\n}\n\nconst Eigen::VectorXf& TriMesh::GetFaceAreas() const {\n if (!face_areas_) {\n CalculateFaceAreas();\n }\n return *face_areas_;\n}\n\nconst Eigen::MatrixXf& TriMesh::GetCotangentWeights() const {\n if (!cotangent_weights_) {\n CalculateCotangentWeights();\n }\n return *cotangent_weights_;\n}\n\nconst Eigen::VectorXf& TriMesh::GetVertexAreas() const {\n if (!vertex_areas_) {\n CalculateVertexAreas();\n }\n return *vertex_areas_;\n}\n\nconst Eigen::MatrixXi& TriMesh::GetAdjacentFacePairs() const {\n if (!adjacent_face_pairs_) {\n BuildAdjacentFacePairs();\n }\n return *adjacent_face_pairs_;\n}\n\nvoid TriMesh::CalculateVertexNormals() const {\n CalculateFaceNormals();\n vertex_normals_ = std::make_unique(\n Eigen::MatrixXf::Zero(GetNumVertices(), 3));\n for (int i = 0; i < static_cast(GetNumFaces()); i++) {\n int v1 = faces_(i, 0);\n int v2 = faces_(i, 1);\n int v3 = faces_(i, 2);\n Eigen::Vector3f n = face_normals_->row(i);\n vertex_normals_->row(v1) += n;\n vertex_normals_->row(v2) += n;\n vertex_normals_->row(v3) += n;\n }\n\n for (int i = 0; i < static_cast(GetNumVertices()); i++) {\n vertex_normals_->row(i).normalize();\n }\n}\n\nvoid TriMesh::CalculateFaceNormals() const {\n face_normals_ = std::make_unique(GetNumFaces(), 3);\n for (int i = 0; i < GetNumFaces(); i++) {\n int v1 = faces_(i, 0);\n int v2 = faces_(i, 1);\n int v3 = faces_(i, 2);\n Eigen::Vector3f p1 = vertices_.row(v1);\n Eigen::Vector3f p2 = vertices_.row(v2);\n Eigen::Vector3f p3 = vertices_.row(v3);\n face_normals_->row(i) = (p2 - p1).cross(p3 - p1);\n }\n}\n\nvoid TriMesh::CalculateFaceAreas() const {\n auto& face_normals = GetFaceNormals();\n face_areas_ = std::make_unique(GetNumFaces());\n for (int k = 0; k < GetNumFaces(); k++) {\n (*face_areas_)(k) = face_normals.row(k).norm() / 2;\n }\n}\n\nvoid TriMesh::CalculateCotangentWeights() const {\n Eigen::MatrixXf p1(faces_.rows(), 3);\n Eigen::MatrixXf p2(faces_.rows(), 3);\n Eigen::MatrixXf p3(faces_.rows(), 3);\n for (int i = 0; i < faces_.rows(); i++) {\n p1.row(i) = vertices_.row(faces_(i, 0));\n p2.row(i) = vertices_.row(faces_(i, 1));\n p3.row(i) = vertices_.row(faces_(i, 2));\n }\n\n Eigen::VectorXf l1 = (p2 - p3).rowwise().norm();\n Eigen::VectorXf l2 = (p1 - p3).rowwise().norm();\n Eigen::VectorXf l3 = (p1 - p2).rowwise().norm();\n Eigen::VectorXf s = (l1 + l2 + l3) / 2;\n Eigen::VectorXf r = (s - l1)\n .cwiseProduct(s - l2)\n .cwiseProduct(s - l3)\n .cwiseQuotient(s)\n .cwiseSqrt();\n\n auto fn = [&](const Eigen::VectorXf& l) -> Eigen::VectorXf {\n return ((s - l).cwiseAbs2() - r.cwiseAbs2())\n .cwiseQuotient(2 * (s - l).cwiseProduct(r));\n };\n\n cotangent_weights_ = std::make_unique(GetNumFaces(), 3);\n cotangent_weights_->col(0) = fn(l1);\n cotangent_weights_->col(1) = fn(l2);\n cotangent_weights_->col(2) = fn(l3);\n}\n\nvoid TriMesh::CalculateVertexAreas() const {\n vertex_areas_ = std::make_unique(\n Eigen::VectorXf::Zero(GetNumVertices()));\n for (int k = 0; k < GetNumFaces(); k++) {\n Eigen::Vector3f n = face_normals_->row(k);\n float a = n.norm() / 6;\n for (int i = 0; i < 3; i++) {\n (*vertex_areas_)(faces_(k, i)) += a;\n }\n }\n}\n\nvoid TriMesh::BuildAdjacentFacePairs() const {\n std::vector face_pairs;\n std::unordered_map edge_neighbor_;\n\n for (int i = 0; i < GetNumFaces(); i++) {\n for (int k = 0; k < 3; k++) {\n int u = faces_(i, k);\n int v = faces_(i, (k + 1) % 3);\n\n if (edge_neighbor_.count({v, u})) {\n face_pairs.emplace_back(i, edge_neighbor_[{v, u}]);\n } else {\n edge_neighbor_.emplace(Vector2i{u, v}, i);\n }\n }\n }\n\n adjacent_face_pairs_ =\n std::make_unique(ArrayVector2iToMatrixXi(face_pairs));\n}\n} // namespace geomlib\n", "meta": {"hexsha": "200fd2339043b669e30fb43bd8b306b048d45658", "size": 4456, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "geomlib/geomlib/TriMesh.cpp", "max_stars_repo_name": "KaiSut0/interactive-hex-meshing", "max_stars_repo_head_hexsha": "187c926610ca5617f569405c23ab5a62b189e100", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 129.0, "max_stars_repo_stars_event_min_datetime": "2021-09-07T17:15:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T08:59:02.000Z", "max_issues_repo_path": "geomlib/geomlib/TriMesh.cpp", "max_issues_repo_name": "KaiSut0/interactive-hex-meshing", "max_issues_repo_head_hexsha": "187c926610ca5617f569405c23ab5a62b189e100", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2021-10-03T07:30:20.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-06T16:05:41.000Z", "max_forks_repo_path": "geomlib/geomlib/TriMesh.cpp", "max_forks_repo_name": "KaiSut0/interactive-hex-meshing", "max_forks_repo_head_hexsha": "187c926610ca5617f569405c23ab5a62b189e100", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11.0, "max_forks_repo_forks_event_min_datetime": "2021-09-08T11:29:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T08:39:50.000Z", "avg_line_length": 28.9350649351, "max_line_length": 79, "alphanum_fraction": 0.6214093357, "num_tokens": 1416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256313782277, "lm_q2_score": 0.7122321903471563, "lm_q1q2_score": 0.599575313326893}} {"text": "#include \n#include \n#include \n#include \n\n#include \n\nusing namespace std;\n\nclass Node {\n public:\n Node(string name) : name_(name) { }\n virtual ~Node() { cout << \"Node destructor\" << endl; }\n void AddParent(Node *parent) {\n parents_.push_back(parent);\n parent->children_.push_back(this);\n parent->pindex_.push_back(parents_.size() - 1);\n }\n Node *Parent(size_t i) const { return parents_[i]; }\n Node *Child(size_t i) const { return children_[i]; }\n size_t NumParents() const { return parents_.size(); }\n size_t NumChildren() const { return children_.size(); }\n string name() const { return name_; }\n size_t pindex(size_t i) const { return pindex_[i]; }\n void NullifyParent(size_t i) { parents_[i] = nullptr; }\n void DeleteAscendantsAndSelf() { DeleteAscendantsAndThis(this); }\n void DeleteAscendantsAndThis(Node *node) {\n for (int i = node->NumParents() - 1; i >= 0; --i) {\n if (node->Parent(i) != nullptr) {\n DeleteAscendantsAndThis(node->Parent(i));\n }\n }\n cout << \"Nullifying \" << node->name() << \" from its children: \";\n for (size_t i = 0; i < node->NumChildren(); ++i) {\n cout << node->Child(i)->name() << \" \";\n node->Child(i)->NullifyParent(node->pindex(i));\n }\n cout << endl;\n\n delete node;\n }\n vector pindex_;\n protected:\n string name_;\n vector parents_;\n vector children_;\n\n};\n\nclass Variable: public Node {\n public:\n Variable(string name) : Node(name) { }\n ~Variable() { }\n Variable *Parent(size_t i) {\n return static_cast(Node::Parent(i));\n }\n virtual void forward() = 0;\n virtual void backward() = 0;\n size_t NumRows() { return gradient_.rows(); }\n size_t NumColumns() { return gradient_.cols(); }\n virtual Eigen::MatrixXd *value() { return &value_; }\n virtual Eigen::MatrixXd *gradient() { return &gradient_; }\n void make_final() { gradient_ = Eigen::MatrixXd::Ones(1, 1); }\n protected:\n Eigen::MatrixXd value_;\n Eigen::MatrixXd gradient_;\n};\n\nstruct Input: public Variable {\n Input(string name, Eigen::MatrixXd *input) : Variable(name) {\n input_ = input;\n gradient_ = Eigen::MatrixXd::Zero(input->rows(), input->cols());\n }\n ~Input() { cout << \"Deleting \" << name_ << endl; }\n Eigen::MatrixXd *value() override { return input_; }\n void forward() override { }\n void backward() override { }\n protected:\n Eigen::MatrixXd *input_;\n};\n\nstruct Add: public Variable {\n Add(string name, Variable *X, Variable *Y) : Variable(name) {\n AddParent(X);\n AddParent(Y);\n gradient_ = Eigen::MatrixXd::Zero(X->NumRows(), X->NumColumns());\n\n }\n ~Add() { cout << \"Deleting \" << name_ << endl; }\n void forward() override {\n Parent(0)->forward();\n Parent(1)->forward();\n value_ = *Parent(0)->value() + *Parent(1)->value();\n }\n void backward() override {\n cout << name_ << \" has parents \" << Parent(0)->name() << \" and \"\n << Parent(1)->name() << \", adding \" << gradient_\n << \" to each\" << endl;\n *Parent(0)->gradient() += gradient_; // dA = dC\n *Parent(1)->gradient() += gradient_; // dB = dC\n cout << \"recursively calling backward from \" << name_\n << \" on its first parent \" << Parent(0)->name() << endl;\n Parent(0)->backward();\n if (Parent(0) != Parent(1)) {\n cout << \"recursively calling backward from \" << name_\n << \" on its second parent \" << Parent(1)->name() << endl;\n Parent(1)->backward();\n }\n }\n};\n\nint main() {\n Eigen::MatrixXd x_value(1, 1);\n x_value << 1.0;\n Eigen::MatrixXd y_value(1, 1);\n y_value << 2.0;\n Input *x = new Input(\"x\", &x_value);\n Input *y = new Input(\"y\", &y_value);\n Add *z = new Add(\"z\", x, y);\n\n Add *q = new Add(\"q\", z, x);\n Add *l = new Add(\"l\", q, q);\n l->make_final();\n l->forward();\n l->backward();\n cout << endl;\n cout << \"x = \" << *x->value() << endl;\n cout << \"dx = \" << *x->gradient() << endl;\n cout << endl;\n cout << \"y = \" << *y->value() << endl;\n cout << \"dy = \" << *y->gradient() << endl;\n cout << endl;\n cout << \"z = \" << *z->value() << endl;\n cout << \"dz = \" << *z->gradient() << endl;\n cout << endl;\n cout << \"q = \" << *q->value() << endl;\n cout << \"dq = \" << *q->gradient() << endl;\n cout << endl;\n cout << \"l = \" << *l->value() << endl;\n cout << \"dl = \" << *l->gradient() << endl;\n cout << endl;\n\n x_value += 0.1 * *x->gradient();\n y_value += 0.1 * *y->gradient();\n\n l->DeleteAscendantsAndSelf();\n\n cout << endl;\n cout << \"x_value is updated to \" << x_value << endl;\n cout << \"y_value is updated to \" << y_value << endl;\n cout << endl;\n\n\n return 0;\n}\n", "meta": {"hexsha": "9422bb7b5ba88f362b9b336fba5b9689439a9caf", "size": 4605, "ext": "cc", "lang": "C++", "max_stars_repo_path": "notes/variable_prototype_stale/main.cc", "max_stars_repo_name": "karlstratos/mesosphere", "max_stars_repo_head_hexsha": "efb6774e94aa4ed60aaba5bf5ad4c0a3e79506b0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-05-17T22:18:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-17T22:18:39.000Z", "max_issues_repo_path": "notes/variable_prototype_stale/main.cc", "max_issues_repo_name": "karlstratos/stratosphere_nn", "max_issues_repo_head_hexsha": "efb6774e94aa4ed60aaba5bf5ad4c0a3e79506b0", "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": "notes/variable_prototype_stale/main.cc", "max_forks_repo_name": "karlstratos/stratosphere_nn", "max_forks_repo_head_hexsha": "efb6774e94aa4ed60aaba5bf5ad4c0a3e79506b0", "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": 29.5192307692, "max_line_length": 69, "alphanum_fraction": 0.5800217155, "num_tokens": 1360, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256393148982, "lm_q2_score": 0.7122321781307374, "lm_q1q2_score": 0.5995753086955504}} {"text": "#include \n#include \n#include \nusing namespace std;\nusing boost::typeindex::type_id_with_cvr;\n\n// 如果使用 string 保留单位名称会导致自定义字符串字面值出错，因为 string 有一个 non_trivial 的构造函数\ntemplate >\nstruct Distance{\n\tusing Ratio = Rat;\n\tRep dis;\n};\n\ntemplate >\nauto operator+(Distance lhs, Distance rhs){\n\treturn Distance{lhs.dis + rhs.dis, };\n}\n\ntemplate >\nauto operator-(Distance lhs, Distance rhs){\n\treturn Distance{lhs.dis - rhs.dis};\n}\n\ntemplate \nusing kilometers = Distance;\n\ntemplate \nusing meters = Distance;\n\ntemplate \nusing decimeters = Distance;\n\ntemplate \nusing centimeters = Distance;\n\ntemplate \nusing miles = Distance>;\n\ntemplate \nusing yards = Distance>;\n\ntemplate \nusing feet = Distance>;\n\ntemplate \nusing inches = Distance>;\n\n\nconstexpr kilometers operator\"\"_km(long double dist){\n\treturn kilometers{dist};\n}\n\nconstexpr meters operator\"\"_m(long double dist){\n\treturn meters{dist};\n}\n\nconstexpr decimeters operator\"\"_dm(long double dist){\n\treturn decimeters{dist};\n}\n\nconstexpr centimeters operator\"\"_cm(long double dist){\n\treturn centimeters{dist};\n}\n\nconstexpr miles operator\"\"_mi(long double dist){\n\treturn miles{dist};\n}\n\nconstexpr yards operator\"\"_yd(long double dist){\n\treturn yards{dist};\n}\n\nconstexpr feet operator\"\"_ft(long double dist){\n\treturn feet{dist};\n}\n\nconstexpr inches operator\"\"_in(long double dist){\n\treturn inches{dist};\n}\n\ntemplate \nostream& operator<<(ostream& os, kilometers len){\n\treturn os << len.dis << \"km\";\n}\n\ntemplate \nostream& operator<<(ostream& os, meters len){\n\treturn os << len.dis << \"m\";\n}\n\n\ntemplate \nostream& operator<<(ostream& os, decimeters len){\n\treturn os << len.dis << \"dm\";\n}\n\n\ntemplate \nostream& operator<<(ostream& os, centimeters len){\n\treturn os << len.dis << \"cm\";\n}\n\ntemplate \nostream& operator<<(ostream& os, miles len){\n\treturn os << len.dis << \"mi\";\n}\n\ntemplate \nostream& operator<<(ostream& os, yards len){\n\treturn os << len.dis << \"yd\";\n}\n\ntemplate \nostream& operator<<(ostream& os, feet len){\n\treturn os << len.dis << \"ft\";\n}\n\ntemplate \nostream& operator<<(ostream& os, inches len){\n\treturn os << len.dis << \"in\";\n}\n\n\ntemplate \nconstexpr To unit_cast(From from){\n\tusing to_ratio = typename To::Ratio;\n\tusing from_ratio = typename From::Ratio;\n\tusing cast_ratio = std::ratio_divide;\n\treturn To{from.dis * cast_ratio::num / cast_ratio::den};\n}\n\n\nint main(int argc, char const *argv[])\n{\n\tauto kms_1 = 10.24_km;\n\tauto kms_2 = 10.24_km;\n\tauto kms_3 = kms_1 + kms_2;\n\tauto mil_1 = 1.0_mi;\n\tauto mil_2 = 1.0_mi;\n\tauto mil_3 = mil_1 + mil_2;\n\tcout << type_id_with_cvr().pretty_name() << endl;\n\tcout << type_id_with_cvr().pretty_name() << endl;\n\tcout << kms_3 << endl;\n\tcout << mil_3 << endl;\n\tcout << unit_cast>(mil_3) << endl;\n\tcout << unit_cast>(mil_3) << endl;\n\tcout << unit_cast>(mil_3) << endl;\n\tcout << unit_cast>(mil_3) << endl;\n\tcout << unit_cast>(kms_3) << endl;\n\tcout << unit_cast>(kms_3) << endl;\n\tcout << unit_cast>(kms_3) << endl;\n\tcout << unit_cast>(kms_3) << endl;\n\tcout << unit_cast>(1.0_mi) << endl;\n\treturn 0;\n}", "meta": {"hexsha": "b933937817bfcb35a7c474d3b2dc1f849a60b6f7", "size": 4040, "ext": "cc", "lang": "C++", "max_stars_repo_path": "Function_Programming/Unit_Subsystem/Unit_Subsystem.cc", "max_stars_repo_name": "Phoenix500526/CodingDojo", "max_stars_repo_head_hexsha": "8214720b51b3f70ce2e518eb795054c7bbcec9c9", "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": "Function_Programming/Unit_Subsystem/Unit_Subsystem.cc", "max_issues_repo_name": "Phoenix500526/CodingDojo", "max_issues_repo_head_hexsha": "8214720b51b3f70ce2e518eb795054c7bbcec9c9", "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": "Function_Programming/Unit_Subsystem/Unit_Subsystem.cc", "max_forks_repo_name": "Phoenix500526/CodingDojo", "max_forks_repo_head_hexsha": "8214720b51b3f70ce2e518eb795054c7bbcec9c9", "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.064516129, "max_line_length": 67, "alphanum_fraction": 0.7017326733, "num_tokens": 1119, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085909370423, "lm_q2_score": 0.7634837743174788, "lm_q1q2_score": 0.5995703670125541}} {"text": "/** \\file gauss_distribution.hpp \n \\brief Gaussian probability distribution */\n/*\n-------------------------------------------------------------------------\n This file is part of BayesOpt, an efficient C++ library for \n Bayesian optimization.\n\n Copyright (C) 2011-2015 Ruben Martinez-Cantin \n \n BayesOpt is free software: you can redistribute it and/or modify it \n 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 BayesOpt is distributed in the hope that it will be useful, but \n 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 BayesOpt. If not, see .\n------------------------------------------------------------------------\n*/\n\n\n#ifndef __GAUSS_DISTRIBUTION_HPP__\n#define __GAUSS_DISTRIBUTION_HPP__\n\n#include \n#include \"prob_distribution.hpp\"\n\nnamespace bayesopt\n{\n\n class GaussianDistribution: public ProbabilityDistribution\n {\n public:\n GaussianDistribution(randEngine& eng);\n virtual ~GaussianDistribution();\n\n /** \n * \\brief Sets the mean and std of the distribution\n */\n void setMeanAndStd(double mean, double std)\n { mean_ = mean; std_ = std; };\n\n /** \n * \\brief Probability density function\n * @param x query point\n * @return probability\n */\n double pdf(double x) \n {\n x = (x - mean_) / std_;\n return boost::math::pdf(d_,x); \n };\n\n /** \n * \\brief Expected Improvement algorithm for minimization\n * @param min minimum value found\n * @param g exponent (used for annealing)\n *\n * @return negative value of the expected improvement\n */\n double negativeExpectedImprovement(double min, size_t g);\n\n /** \n * \\brief Lower confindence bound. Can be seen as the inverse of the Upper \n * confidence bound\n * @param beta std coefficient (used for annealing)\n * @return value of the lower confidence bound\n */\n double lowerConfidenceBound(double beta);\n\n /** \n * Probability of improvement algorithm for minimization\n * @param min minimum value found\n * @param epsilon minimum improvement margin\n * \n * @return negative value of the probability of improvement\n */\n double negativeProbabilityOfImprovement(double min,\n\t\t\t\t\t double epsilon);\n\n /** \n * Sample outcome acording to the marginal distribution at the query point.\n * @return outcome\n */\n double sample_query();\n\n double getMean() { return mean_; };\n double getStd() { return std_; };\n\n\n private:\n boost::math::normal d_;\n double mean_;\n double std_;\n };\n\n} //namespace bayesopt\n\n#endif\n", "meta": {"hexsha": "bac66b859dd937484de19091392d84e8f8b3262a", "size": 2992, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "external/bayesopt/include/gauss_distribution.hpp", "max_stars_repo_name": "pchrapka/brain-modelling", "max_stars_repo_head_hexsha": "f232b5a858e45f10b0b0735269010454129ab017", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-10-13T19:37:52.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-13T19:37:52.000Z", "max_issues_repo_path": "external/bayesopt/include/gauss_distribution.hpp", "max_issues_repo_name": "pchrapka/brain-modelling", "max_issues_repo_head_hexsha": "f232b5a858e45f10b0b0735269010454129ab017", "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": "external/bayesopt/include/gauss_distribution.hpp", "max_forks_repo_name": "pchrapka/brain-modelling", "max_forks_repo_head_hexsha": "f232b5a858e45f10b0b0735269010454129ab017", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-11-25T12:22:05.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-25T12:22:05.000Z", "avg_line_length": 28.7692307692, "max_line_length": 79, "alphanum_fraction": 0.6497326203, "num_tokens": 661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872046026642944, "lm_q2_score": 0.6757645879592641, "lm_q1q2_score": 0.5995414527549995}} {"text": "/*\n * Copyright (C) 2016-2019 Istituto Italiano di Tecnologia (IIT)\n *\n * This software may be modified and distributed under the terms of the\n * BSD 3-Clause license. See the accompanying LICENSE file for details.\n */\n\n#include \n#include \n\n#include \n\nusing namespace bfl;\nusing namespace bfl::directional_statistics;\nusing namespace bfl::sigma_point;\nusing namespace Eigen;\n\n\nbfl::sigma_point::UTWeight::UTWeight\n(\n std::size_t n,\n const double alpha,\n const double beta,\n const double kappa\n) :\n mean((2 * n) + 1),\n covariance((2 * n) + 1)\n{\n unscented_weights(n, alpha, beta, kappa, mean, covariance, c);\n}\n\n\nvoid bfl::sigma_point::unscented_weights\n(\n const std::size_t n,\n const double alpha,\n const double beta,\n const double kappa,\n Ref weight_mean,\n Ref weight_covariance,\n double& c\n)\n{\n double lambda = std::pow(alpha, 2.0) * (n + kappa) - n;\n\n for (int j = 0; j < ((2 * n) + 1); ++j)\n {\n if (j == 0)\n {\n weight_mean(j) = lambda / (n + lambda);\n weight_covariance(j) = lambda / (n + lambda) + (1 - std::pow(alpha, 2.0) + beta);\n }\n else\n {\n weight_mean(j) = 1 / (2 * (n + lambda));\n weight_covariance(j) = weight_mean(j);\n }\n }\n\n c = n + lambda;\n}\n\n\nMatrixXd bfl::sigma_point::sigma_point(const GaussianMixture& state, const double c)\n{\n MatrixXd sigma_points(state.dim, ((state.dim * 2) + 1) * state.components);\n\n for (std::size_t i = 0; i < state.components; i++)\n {\n JacobiSVD svd = state.covariance(i).jacobiSvd(ComputeThinU);\n\n MatrixXd A = svd.matrixU() * svd.singularValues().cwiseSqrt().asDiagonal();\n\n Ref sp = sigma_points.middleCols(((state.dim * 2) + 1) * i, ((state.dim * 2) + 1));\n\n sp << VectorXd::Zero(state.dim), std::sqrt(c) * A, -std::sqrt(c) * A;\n\n if (state.dim_linear > 0)\n sp.topRows(state.dim_linear).colwise() += state.mean(i).topRows(state.dim_linear);\n\n if (state.dim_circular > 0)\n sp.middleRows(state.dim_linear, state.dim_circular) = directional_add(sp.middleRows(state.dim_linear, state.dim_circular), state.mean(i).middleRows(state.dim_linear, state.dim_circular));\n\n if (state.dim_noise > 0)\n sp.bottomRows(state.dim_noise).colwise() += state.mean(i).bottomRows(state.dim_noise);\n }\n\n return sigma_points;\n}\n\n\nstd::tuple bfl::sigma_point::unscented_transform\n(\n const GaussianMixture& input,\n const UTWeight& weight,\n FunctionEvaluation function\n)\n{\n /* Sample sigma points. */\n MatrixXd input_sigma_points = sigma_point::sigma_point(input, weight.c);\n\n /* Propagate sigma points */\n Data fun_data;\n bool valid_fun_data;\n bfl::sigma_point::OutputSize output_size;\n std::tie(valid_fun_data, fun_data, output_size) = function(input_sigma_points);\n\n /* Stop here if function evaluation failed. */\n if (!valid_fun_data)\n return std::make_tuple(false, GaussianMixture(), MatrixXd(0, 0));\n\n /* For now casting Data to MatrixXd. */\n MatrixXd prop_sigma_points = bfl::any::any_cast(std::move(fun_data));\n\n /* Initialize transformed gaussian. */\n GaussianMixture output(input.components, output_size.first, output_size.second);\n\n /* Initialize cross covariance matrix. */\n MatrixXd cross_covariance(input.dim, output.dim * output.components);\n\n /* Process all the components of the mixture. */\n std::size_t base = ((input.dim * 2) + 1);\n for (std::size_t i = 0; i < input.components; i++)\n {\n Ref input_sigma_points_i = input_sigma_points.middleCols(base * i, base);\n Ref prop_sigma_points_i = prop_sigma_points.middleCols(base * i, base);\n\n /* Evaluate the mean. */\n output.mean(i).topRows(output_size.first).noalias() = prop_sigma_points_i.topRows(output_size.first) * weight.mean;\n output.mean(i).bottomRows(output_size.second) = directional_mean(prop_sigma_points_i.bottomRows(output_size.second), weight.mean);\n\n /* Evaluate the covariance. */\n prop_sigma_points_i.topRows(output_size.first).colwise() -= output.mean(i).topRows(output_size.first);\n prop_sigma_points_i.bottomRows(output_size.second) = directional_sub(prop_sigma_points_i.bottomRows(output_size.second), output.mean(i).bottomRows(output_size.second));\n output.covariance(i).noalias() = prop_sigma_points_i * weight.covariance.asDiagonal() * prop_sigma_points_i.transpose();\n\n /* Evaluate the input-output cross covariance matrix\n (noise components in the input are not considered). */\n Ref cross_covariance_i = cross_covariance.middleCols(output.dim * i, output.dim);\n input_sigma_points_i.topRows(input.dim_linear).colwise() -= input.mean(i).topRows(input.dim_linear);\n input_sigma_points_i.middleRows(input.dim_linear, input.dim_circular) = directional_sub(input_sigma_points_i.middleRows(input.dim_linear, input.dim_circular), input.mean(i).middleRows(input.dim_linear, input.dim_circular));\n cross_covariance_i.noalias() = input_sigma_points_i.topRows(input.dim_linear + input.dim_circular) * weight.covariance.asDiagonal() * prop_sigma_points_i.transpose();\n }\n\n return std::make_tuple(true, output, cross_covariance);\n}\n\n\nstd::pair bfl::sigma_point::unscented_transform\n(\n const GaussianMixture& state,\n const UTWeight& weight,\n StateModel& state_model\n)\n{\n FunctionEvaluation f = [&state_model](const Ref& state)\n {\n MatrixXd tmp(state.rows(), state.cols());\n\n state_model.motion(state, tmp);\n\n return std::make_tuple(true, std::move(tmp), state_model.getOutputSize());\n };\n MatrixXd cross_covariance;\n GaussianMixture output;\n std::tie(std::ignore, output, cross_covariance) = unscented_transform(state, weight, f);\n\n return std::make_pair(output, cross_covariance);\n}\n\n\nstd::pair bfl::sigma_point::unscented_transform\n(\n const GaussianMixture& state,\n const UTWeight& weight,\n AdditiveStateModel& state_model\n)\n{\n FunctionEvaluation f = [&state_model](const Ref& state)\n {\n MatrixXd tmp(state.rows(), state.cols());\n\n state_model.propagate(state, tmp);\n\n return std::make_tuple(true, std::move(tmp), state_model.getOutputSize());\n };\n\n MatrixXd cross_covariance;\n GaussianMixture output;\n std::tie(std::ignore, output, cross_covariance) = unscented_transform(state, weight, f);\n\n /* In the additive case the covariance matrix is augmented with the noise\n covariance matrix. */\n for(std::size_t i = 0; i < state.components; i++)\n output.covariance(i) += state_model.getNoiseCovarianceMatrix();\n\n return std::make_pair(output, cross_covariance);\n}\n\n\nstd::tuple bfl::sigma_point::unscented_transform\n(\n const GaussianMixture& state,\n const UTWeight& weight,\n MeasurementModel& meas_model\n)\n{\n FunctionEvaluation f = [&meas_model](const Ref& state)\n {\n bool valid_prediction;\n bfl::Data prediction;\n\n std::tie(valid_prediction, prediction) = meas_model.predictedMeasure(state);\n\n return std::make_tuple(valid_prediction, std::move(prediction), meas_model.getOutputSize());\n };\n\n bool valid;\n MatrixXd cross_covariance;\n GaussianMixture output;\n std::tie(valid, output, cross_covariance) = unscented_transform(state, weight, f);\n\n return std::make_tuple(valid, output, cross_covariance);\n}\n\n\nstd::tuple bfl::sigma_point::unscented_transform\n(\n const GaussianMixture& state,\n const UTWeight& weight,\n AdditiveMeasurementModel& meas_model\n)\n{\n FunctionEvaluation f = [&meas_model](const Ref& state)\n {\n bool valid_prediction;\n bfl::Data prediction;\n\n std::tie(valid_prediction, prediction) = meas_model.predictedMeasure(state);\n\n return std::make_tuple(valid_prediction, std::move(prediction), meas_model.getOutputSize());\n };\n\n bool valid;\n MatrixXd cross_covariance;\n GaussianMixture output;\n std::tie(valid, output, cross_covariance) = unscented_transform(state, weight, f);\n\n /* In the additive case the covariance matrix is augmented with the noise\n covariance matrix. */\n MatrixXd noise_cov;\n std::tie(std::ignore, noise_cov) = meas_model.getNoiseCovarianceMatrix();\n for (std::size_t i = 0; i < state.components; i++)\n output.covariance(i) += noise_cov;\n\n return std::make_tuple(valid, output, cross_covariance);\n}\n", "meta": {"hexsha": "4f540fa26e397e9e6a2afaa3bcea8426983d8910", "size": 9320, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/BayesFilters/src/sigma_point.cpp", "max_stars_repo_name": "mfkiwl/bayes-filters-lib", "max_stars_repo_head_hexsha": "8baabba1897bcc5634619fbc048bb5ab17a742da", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 50.0, "max_stars_repo_stars_event_min_datetime": "2017-04-12T09:02:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T20:01:35.000Z", "max_issues_repo_path": "src/BayesFilters/src/sigma_point.cpp", "max_issues_repo_name": "xEnVrE/bayes-filters-lib", "max_issues_repo_head_hexsha": "8baabba1897bcc5634619fbc048bb5ab17a742da", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 79.0, "max_issues_repo_issues_event_min_datetime": "2017-11-07T07:32:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-20T17:12:08.000Z", "max_forks_repo_path": "src/BayesFilters/src/sigma_point.cpp", "max_forks_repo_name": "xEnVrE/bayes-filters-lib", "max_forks_repo_head_hexsha": "8baabba1897bcc5634619fbc048bb5ab17a742da", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 23.0, "max_forks_repo_forks_event_min_datetime": "2017-05-07T01:47:39.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T10:15:59.000Z", "avg_line_length": 36.1240310078, "max_line_length": 231, "alphanum_fraction": 0.6491416309, "num_tokens": 2167, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513703624558, "lm_q2_score": 0.6688802669716106, "lm_q1q2_score": 0.5994848558817113}} {"text": "#include\n#include\n#include\n#include\n#include \"ray.h\"\n#include \n#include \n#include \nusing namespace std;\nusing namespace Eigen;\n\n\nVector3d operator*(double s, const Vector3d &v) {\n\treturn Vector3d(s*v(0), s*v(1), s*v(2));\n}\n\n//Triangle with verticies pos, pos + p and pos + q.\nclass triangle: public shape {\n\tVector3d p, q, normal;\t\n\tpublic:\n\tVector3d pos;\n\ttriangle(Vector3d np, Vector3d nq, Vector3d npos, colour &ncol, surface &s):\n\t\tp(np), q(nq), pos(npos) {\n\t\tcol = ncol;\n\t\tsurf = s;\n\t\tnormal = p.cross(q);\n\t}\n\t\n\tVector3d get_normal(const Vector3d ignore) const {\n\t\treturn normal;\n\t}\n\t\n\t//Moller-Trumbore intersection algorithm\n\tdouble intersect(ray r) {\n\t\tVector3d vec, T;\n\t\tdouble det, u, v, t;\n\t\tvec = r.dir.cross(q);\n\t\tdet = p.dot(vec);\n\t\t//std::cout << \"det = \" << det << std::endl;\n\t\t//If det is zero then ray in plane of triangle\n\t\tif(det < INTERSECT_EPSILON && det > -INTERSECT_EPSILON) return 0.0;\n\t\t//Get ray from pos to ray origin\n\t\tT = r.origin - pos;\n\t\tu = T.dot(vec)/det;\n\t\t//Test u\n\t\tif(u < 0 || u > 1.0) return 0.0;\n\t\t//and v (+u)\n\t\tvec = T.cross(p);\n\t\tv = r.dir.dot(vec)/det;\n\t\tif(v < 0 || v + u > 1.0) return 0.0;\n\t\t//Intersect at origin + t*dir\n\t\tt = q.dot(vec)/det;\n\t\t//Check we're not behind the ray origin\n\t\tif(t < INTERSECT_EPSILON) return 0.0;\n\t\t//return ray intersect parameter: point = Origin + t*dir\n\t\treturn t;\n\t}\n\t \n};\n\nclass sphere: public shape {\n\tpublic:\n\tVector3d pos;\n\tdouble radius;\n\tsphere(double nr, Vector3d np, colour &ncol, surface &s):\n\t\tpos(np), radius(nr){\n\t\tcol = ncol;\n\t\tsurf = s;\n\t}\n\t\n\tVector3d get_normal(const Vector3d p) const {\n\t\treturn p - pos;\n\t}\n\n\tdouble intersect(ray r) {\n\t\tdouble a, b, c, d, dsq, s1, s2;\n\t\tc = r.origin.dot(r.origin) + pos.dot(pos) - 2*r.origin.dot(pos) - radius*radius;\n\t\tb = 2 * r.dir.dot(r.origin - pos);\n\t\ta = r.dir.dot(r.dir);\n\t\tif(a < INTERSECT_EPSILON) {\n\t\t\tfprintf(stderr, \"Warn: sphere::intersect: a < ITERSECT_EPSILON\\n\");\n\t\t\treturn 0.0;\n\t\t}\n\t\tdsq = b*b - 4*a*c;\n\t\tif(dsq <= 0) {\n\t\t\treturn 0;\n\t\t}\n\t\td = std::sqrt(dsq);\n\t\ts1 = (-b+d)/(2*a);\n\t\ts2 = (-b-d)/(2*a);\n\t\tif(s1 < s2) {\n\t\t\tif(s1 > INTERSECT_EPSILON) {\n\t\t\t\treturn s1;\n\t\t\t}\n\t\t}\n\t\tif(s2 > INTERSECT_EPSILON) {\n\t\t\treturn s2;\n\t\t} else {\n\t\t\treturn s1 > INTERSECT_EPSILON ? s1 : 0.0;\n\t\t}\n\t}\n\t\n};\n\n\n\nstd::vector* getMeshWorld() {\n\tstd::vector *w = new std::vector();\n\t\n\tcolour red = colour(255, 0, 0, 1.0);\n\tcolour blue = colour(0, 0, 255, 1.0);\n\tcolour green = colour(0, 255.0, 0, 1.0);\n\n\tsurface shiny;\n\tshiny.reflection = 0.8;\n\tshiny.specular = 1.0;\n\tshiny.diffusion = 0.9;\n\n\t// w->push_back((shape*) (new sphere(2, Vector3d(0, 3, 15), red, shiny)));\n\n\t\tifstream fin ;\n\t\t\t\t\t // fin.open(\"/Users/Rachit/Documents/iqra_cg/tracer3/bumpy_cube.off\");\n\t\t\t\t\t fin.open(\"/Users/Rachit/Documents/iqra_cg/tracer3/bunny.off\");\n\t\t\t\t\t \n\t\t\t\t\t int nrows,nrows2;\n\t\t\t\t\t string output;\n\t\t\t\t\t if(fin.is_open())\n\t\t\t\t\t {\n\t\t\t\t\t fin >> output;\n\t\t\t\t\t fin >> output;\n\t\t\t\t\t nrows=std::stoi(output);\n\t\t\t\t\t fin >> output;\n\t\t\t\t\t nrows2 = std::stoi(output);\n\t\t\t\t\t fin >> output;\n\n\t\t\t\t\t }\n\n\t\t\t\t\t Eigen::ArrayXXf X = Eigen::ArrayXXf::Zero(nrows,3);\n\t\t\t\t\t Eigen::ArrayXXd Y = Eigen::ArrayXXd::Zero(nrows2,4);\n\n\t\t\t\t\t if (fin.is_open())\n\t\t\t\t\t {\n\t\t\t\t\t for (int row = 0; row < nrows; row++)\n\t\t\t\t\t for (int col = 0; col < 3; col++)\n\t\t\t\t\t {\n\t\t\t\t\t float item = 0.0;\n\t\t\t\t\t fin >> item;\n\t\t\t\t\t X(row, col) = item;\n\t\t\t\t\t }\n\n\t\t\t\t\t }\n\t\t\t\t\t // cerr << \"X = \" << endl << X << endl;\n\t\t\t\t\t if (fin.is_open())\n\t\t\t\t\t {\n\t\t\t\t\t for (int row = 0; row < nrows2; row++)\n\t\t\t\t\t for (int col = 0; col < 4; col++)\n\t\t\t\t\t {\n\t\t\t\t\t float item = 0.0;\n\t\t\t\t\t fin >> item;\n\t\t\t\t\t Y(row, col) = item;\n\t\t\t\t\t }\n\t\t\t\t\t fin.close();\n\t\t\t\t\t }\n\t\t\t\t\t // cerr<<\"Y =\"<< endl << Y <\"<push_back((shape*) (new triangle(\n\t\t\t\t\t \t\t Vector3d(X(Y(k, 1), 0), X(Y(k, 1), 1), X(Y(k, 1), 2)),\n Vector3d(X(Y(k, 2), 0), X(Y(k, 2), 1), X(Y(k, 2), 2)),\n Vector3d(X(Y(k, 3), 0), X(Y(k, 3), 1), X(Y(k, 3), 2)),\n red,shiny\n\t\t\t\t\t \t\t)));\n\n\n}\n\n\n\n\n\n\n\t\n\n\t//One sphere\n\t// w->push_back((shape*) (new sphere(3, Vector3d(5, 5, 10), red, shiny)));\n\t// w->push_back((shape*) (new sphere(1.5, Vector3d(0, 0, -5), red, shiny)));\n\treturn w;\n\n}\n\n\n\nstd::vector* partAWorld() {\n\tstd::vector *w = new std::vector();\n\t\n\tcolour red = colour(255, 0, 0, 1.0);\n\tcolour blue = colour(0, 0, 255, 1.0);\n\tcolour green = colour(0, 255.0, 0, 1.0);\n\n\n\t//SETTING ONLY DIFFUSE as using imple Lambertian shading\n\tsurface lambert;\n\tlambert.reflection = 0.0;\n\tlambert.specular = 0.0;\n\tlambert.diffusion = 0.9;\n\n\tw->push_back((shape*) (new sphere(5, Vector3d(0, 3, 15), red, lambert)));\n\tw->push_back((shape*) (new sphere(5, Vector3d(10, 10, 15), red, lambert)));\n\n\t// w->push_back((shape*) (new sphere(3, Vector3d(5, 5, 10), red, shiny)));\n\t// w->push_back((shape*) (new sphere(1.5, Vector3d(0, 0, -5), red, shiny)));\n\treturn w;\n\n}\nstd::vector* partBWorld() {\n\tstd::vector *w = new std::vector();\n\t\n\tcolour red = colour(255, 0, 0, 1.0);\n\tcolour blue = colour(0, 0, 255, 1.0);\n\tcolour green = colour(0, 255.0, 0, 1.0);\n\n\n\t//SETTING ONLY DIFFUSE as using imple Lambertian shading\n\tsurface lambert;\n\tlambert.reflection = 0.0;\n\tlambert.specular = 0.0;\n\tlambert.diffusion = 0.9;\n\t//Diffuse+specular\n\tsurface specular;\n\tspecular.reflection = 0.0;\n\tspecular.specular = 1.0;\n\tspecular.diffusion = 0.9;\n\n\tw->push_back((shape*) (new sphere(10, Vector3d(0, 3, 15), red, lambert)));\n\tw->push_back((shape*) (new sphere(5, Vector3d(10, 10, 15), blue, specular)));\n\n\t// w->push_back((shape*) (new sphere(3, Vector3d(5, 5, 10), red, shiny)));\n\t// w->push_back((shape*) (new sphere(1.5, Vector3d(0, 0, -5), red, shiny)));\n\treturn w;\n\n}\nstd::vector* partCWorld() {\n\tstd::vector *w = new std::vector();\n\t\n\tcolour red = colour(255, 0, 0, 1.0);\n\tcolour blue = colour(0, 0, 255, 1.0);\n\tcolour green = colour(0, 255.0, 0, 1.0);\n\n\n\t//SETTING ONLY DIFFUSE as using imple Lambertian shading\n\tsurface lambert;\n\tlambert.reflection = 0.0;\n\tlambert.specular = 0.0;\n\tlambert.diffusion = 0.9;\n\t//Diffuse+specular\n\tsurface specular;\n\tspecular.reflection = 0.0;\n\tspecular.specular = 1.0;\n\tspecular.diffusion = 0.9;\n\n\tw->push_back((shape*) (new sphere(10, Vector3d(0, 3, 15), red, lambert)));\n\tw->push_back((shape*) (new sphere(5, Vector3d(10, 10, 15), blue, specular)));\n\n\t// w->push_back((shape*) (new sphere(3, Vector3d(5, 5, 10), red, shiny)));\n\t// w->push_back((shape*) (new sphere(1.5, Vector3d(0, 0, -5), red, shiny)));\n\treturn w;\n\n}\nstd::vector* partEWorld(int n_spheres) {\n\t\n\tsurface shiny;\n\tshiny.reflection = 0.4;\n\tshiny.specular = 1.0;\n\tshiny.diffusion = 0.9;\n\tstd::vector *w = new std::vector();\n\tint i, j, k;\n\tfor(i=0; i<3; i++) {\n\tfor(j=0; j<3; j++) {\n\tfor(k=0; k<3; k++) {\n\t\tif(n_spheres > 0) {\n\t\t\tcolour c = colour(i*127.5, 255-j*127.5, ((int) (127.5+(k*127.5)))%382);\n\t\t\tw->push_back((shape*) (new sphere(1, Vector3d(i*4-5.5, j*4-6, k*4+14), c, shiny)));\n\t\t\tn_spheres -= 1;\n\t\t}\n\t}\n\t}\n\t}\n\treturn w;\n\n}\n\n\n\nvoid freeWorld(std::vector *w) {\n\twhile(w->size() > 0) {\n\t\tdelete (w->back());\n\t\tw->pop_back();\n\t}\n\tdelete w;\n}\n\nstd::vector* getLights() {\n\tstd::vector *l = new std::vector();\n\tl->push_back(new light(Vector3d(15, 15, 5), colour(255, 255, 255)));\n\treturn l;\n}\nstd::vector* partALights() {\n\tstd::vector *l = new std::vector();\n\tl->push_back(new light(Vector3d(15, 15, 5), colour(255, 255, 255)));\n\treturn l;\n}\nstd::vector* partBLights() {\n\tstd::vector *l = new std::vector();\n\tl->push_back(new light(Vector3d(15, 15, 5), colour(255, 255, 255)));\n\tl->push_back(new light(Vector3d(-15, -15, 5), colour(255, 255, 255)));\n\t\t\n\treturn l;\n}\nstd::vector* partELights() {\n\tstd::vector *l = new std::vector();\n\tl->push_back(new light(Vector3d(-5, 3, 2), colour(255, 255, 255)));\n\tl->push_back(new light(Vector3d(15, 15, 5), colour(255, 255, 255)));\n\t\t\n\treturn l;\n}\n\nvoid freeLights(std::vector *l) {\n\twhile(l->size() > 0) {\n\t\tdelete (l->back());\n\t\tl->pop_back();\n\t}\n\tdelete l;\n}\n\n", "meta": {"hexsha": "0c449967876b9868124a72e93c57d3ccdc6b69b6", "size": 8524, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "world.cpp", "max_stars_repo_name": "rachitmehrotra1/ray-tracer", "max_stars_repo_head_hexsha": "5820d5ba5d9783b428ccbc6383a608752cce3ef9", "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": "world.cpp", "max_issues_repo_name": "rachitmehrotra1/ray-tracer", "max_issues_repo_head_hexsha": "5820d5ba5d9783b428ccbc6383a608752cce3ef9", "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": "world.cpp", "max_forks_repo_name": "rachitmehrotra1/ray-tracer", "max_forks_repo_head_hexsha": "5820d5ba5d9783b428ccbc6383a608752cce3ef9", "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": 25.293768546, "max_line_length": 86, "alphanum_fraction": 0.564406382, "num_tokens": 3030, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513675912912, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5994848481123354}} {"text": "#ifndef CPPMATH_MATRIX_PSEUDOINVERSESVD_HPP_\n#define CPPMATH_MATRIX_PSEUDOINVERSESVD_HPP_\n\n#include \n\nnamespace cppmath\n{\n /**\n * Calculates a SVD-based pseudo inverse matrix.\n * See:\n * - http://en.wikipedia.org/wiki/Moore-Penrose_pseudoinverse#The_general_case_and_the_SVD_method\n * - http://eigen.tuxfamily.org/index.php?title=FAQ#Is_there_a_method_to_compute_the_.28Moore-Penrose.29_pseudo_inverse_.3F\n *\n * \\author cpieloth\n * \\copyright Copyright 2014 Christof Pieloth, Licensed under the Apache License, Version 2.0\n */\n template< typename T >\n class PseudoInverseSVD: private Eigen::JacobiSVD< T >\n {\n public:\n /**\n * Constructor.\n *\n * \\param matrix Matrix to compute the pseudo inverse from.\n * \\param pinvThreshold Threshold to keep value as zero/nonzero (default: 1.0e-6).\n */\n PseudoInverseSVD( const T& matrix, float threshold = 1.0e-6 );\n\n virtual ~PseudoInverseSVD();\n\n /**\n * Computes the pseudo inverse.\n * The pseudo inverse is internally stored for further calculations.\n *\n * \\return Reference to the internally stored pseudo inverse matrix.\n */\n const T& compute();\n\n /**\n * Computes the pseudo inverse.\n *\n * \\param pinvmat Holds the pseudo inverse matrix after computation.\n */\n void compute( T* const pinvmat ) const;\n\n /**\n * Multiplies the pseudo inverse with a matrix.\n * The pseudo inverse is internally stored for further calculations.\n *\n * \\param m Matrix\n * \\return Result of pinv*m\n */\n T operator*( const T& m );\n\n /**\n * Multiplies the pseudo inverse with a matrix.\n *\n * \\param m Matrix\n * \\return Result of pinv*m\n */\n T operator*( const T& m ) const;\n\n private:\n bool m_hasInverse; /**< Indicates if the internal inverse matrix is available. */\n\n T m_inverse; /**< Stores a computed inverse matrix. */\n\n const float m_threshold;\n };\n} /* namespace cppmath */\n\n// Load the implementation\n#include \"PseudoInverseSVD-impl.hpp\"\n\n#endif // CPPMATH_MATRIX_PSEUDOINVERSESVD_HPP_\n", "meta": {"hexsha": "68422252cd017cab563547e261dde3b7ac367b23", "size": 2275, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "src/cppmath/matrix/PseudoInverseSVD.hpp", "max_stars_repo_name": "cpieloth/CppMath", "max_stars_repo_head_hexsha": "58d1c7f0ea07dab9f913b946a251a01b0827bb39", "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/cppmath/matrix/PseudoInverseSVD.hpp", "max_issues_repo_name": "cpieloth/CppMath", "max_issues_repo_head_hexsha": "58d1c7f0ea07dab9f913b946a251a01b0827bb39", "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": "src/cppmath/matrix/PseudoInverseSVD.hpp", "max_forks_repo_name": "cpieloth/CppMath", "max_forks_repo_head_hexsha": "58d1c7f0ea07dab9f913b946a251a01b0827bb39", "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": 29.9342105263, "max_line_length": 127, "alphanum_fraction": 0.6184615385, "num_tokens": 540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118222, "lm_q2_score": 0.7310585727705126, "lm_q1q2_score": 0.5993900455424357}} {"text": "\n\n/* --------------------------------------------------------------------- \n * \n * Copyright (C) 2016 - 2021 by the deal.II authors \n * \n * This file is part of the deal.II library. \n * \n * The deal.II library is free software; you can use it, redistribute \n * it, and/or modify it under the terms of the GNU Lesser General \n * Public License as published by the Free Software Foundation; either \n * version 2.1 of the License, or (at your option) any later version. \n * The full text of the license can be found in the file LICENSE.md at \n * the top level directory of deal.II. \n * \n * --------------------------------------------------------------------- \n * \n * Author: Timo Heister, Clemson University, 2016 \n */ \n\n\n\n#include \n#include \n#include \n\n// 下面这块出场代码与 step-40 相同，可以在PETSc和Trilinos之间切换。\n\n#include \n\n/* #define FORCE_USE_OF_TRILINOS */ \n\n\n\nnamespace LA \n{ \n#if defined(DEAL_II_WITH_PETSC) && !defined(DEAL_II_PETSC_WITH_COMPLEX) && \\ \n !(defined(DEAL_II_WITH_TRILINOS) && defined(FORCE_USE_OF_TRILINOS)) \n using namespace dealii::LinearAlgebraPETSc; \n# define USE_PETSC_LA \n#elif defined(DEAL_II_WITH_TRILINOS) \n using namespace dealii::LinearAlgebraTrilinos; \n#else \n# error DEAL_II_WITH_PETSC or DEAL_II_WITH_TRILINOS required \n#endif \n} // namespace LA \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \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 \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace Step55 \n{ \n using namespace dealii; \n// @sect3{Linear solvers and preconditioners} \n\n// 我们需要一些辅助类来表示我们在介绍中描述的求解器策略。\n\n namespace LinearSolvers \n { \n\n// 这个类暴露了通过函数 InverseMatrix::vmult(). 应用给定矩阵的逆的动作，在内部，逆不是显式形成的。相反，一个带有CG的线性求解器被执行。这个类扩展了 step-22 中的InverseMatrix类，增加了一个指定预处理程序的选项，并允许在vmult函数中使用不同的矢量类型。\n\n template \n class InverseMatrix : public Subscriptor \n { \n public: \n InverseMatrix(const Matrix &m, const Preconditioner &preconditioner); \n\n template \n void vmult(VectorType &dst, const VectorType &src) const; \n\n private: \n const SmartPointer matrix; \n const Preconditioner & preconditioner; \n }; \n\n template \n InverseMatrix::InverseMatrix( \n const Matrix & m, \n const Preconditioner &preconditioner) \n : matrix(&m) \n , preconditioner(preconditioner) \n {} \n\n template \n template \n void \n InverseMatrix::vmult(VectorType & dst, \n const VectorType &src) const \n { \n SolverControl solver_control(src.size(), 1e-8 * src.l2_norm()); \n SolverCG cg(solver_control); \n dst = 0; \n\n try \n { \n cg.solve(*matrix, dst, src, preconditioner); \n } \n catch (std::exception &e) \n { \n Assert(false, ExcMessage(e.what())); \n } \n } \n\n// 该类是一个简单的2x2矩阵的块状对角线预处理器的模板类。\n\n template \n class BlockDiagonalPreconditioner : public Subscriptor \n { \n public: \n BlockDiagonalPreconditioner(const PreconditionerA &preconditioner_A, \n const PreconditionerS &preconditioner_S); \n\n void vmult(LA::MPI::BlockVector & dst, \n const LA::MPI::BlockVector &src) const; \n\n private: \n const PreconditionerA &preconditioner_A; \n const PreconditionerS &preconditioner_S; \n }; \n\n template \n BlockDiagonalPreconditioner:: \n BlockDiagonalPreconditioner(const PreconditionerA &preconditioner_A, \n const PreconditionerS &preconditioner_S) \n : preconditioner_A(preconditioner_A) \n , preconditioner_S(preconditioner_S) \n {} \n\n template \n void BlockDiagonalPreconditioner::vmult( \n LA::MPI::BlockVector & dst, \n const LA::MPI::BlockVector &src) const \n { \n preconditioner_A.vmult(dst.block(0), src.block(0)); \n preconditioner_S.vmult(dst.block(1), src.block(1)); \n } \n\n \n// @sect3{Problem setup} \n\n// 下面的类代表测试问题的右手边和精确解。\n\n template \n class RightHandSide : public Function \n { \n public: \n RightHandSide() \n : Function(dim + 1) \n {} \n\n virtual void vector_value(const Point &p, \n Vector & value) const override; \n }; \n\n template \n void RightHandSide::vector_value(const Point &p, \n Vector & values) const \n { \n const double R_x = p[0]; \n const double R_y = p[1]; \n\n const double pi = numbers::PI; \n const double pi2 = pi * pi; \n values[0] = \n -1.0L / 2.0L * (-2 * sqrt(25.0 + 4 * pi2) + 10.0) * \n exp(R_x * (-2 * sqrt(25.0 + 4 * pi2) + 10.0)) - \n 0.4 * pi2 * exp(R_x * (-sqrt(25.0 + 4 * pi2) + 5.0)) * cos(2 * R_y * pi) + \n 0.1 * pow(-sqrt(25.0 + 4 * pi2) + 5.0, 2) * \n exp(R_x * (-sqrt(25.0 + 4 * pi2) + 5.0)) * cos(2 * R_y * pi); \n values[1] = 0.2 * pi * (-sqrt(25.0 + 4 * pi2) + 5.0) * \n exp(R_x * (-sqrt(25.0 + 4 * pi2) + 5.0)) * sin(2 * R_y * pi) - \n 0.05 * pow(-sqrt(25.0 + 4 * pi2) + 5.0, 3) * \n exp(R_x * (-sqrt(25.0 + 4 * pi2) + 5.0)) * sin(2 * R_y * pi) / \n pi; \n values[2] = 0; \n } \n\n template \n class ExactSolution : public Function \n { \n public: \n ExactSolution() \n : Function(dim + 1) \n {} \n\n virtual void vector_value(const Point &p, \n Vector & value) const override; \n }; \n\n template \n void ExactSolution::vector_value(const Point &p, \n Vector & values) const \n { \n const double R_x = p[0]; \n const double R_y = p[1]; \n\n const double pi = numbers::PI; \n const double pi2 = pi * pi; \n values[0] = \n -exp(R_x * (-sqrt(25.0 + 4 * pi2) + 5.0)) * cos(2 * R_y * pi) + 1; \n values[1] = (1.0L / 2.0L) * (-sqrt(25.0 + 4 * pi2) + 5.0) * \n exp(R_x * (-sqrt(25.0 + 4 * pi2) + 5.0)) * sin(2 * R_y * pi) / \n pi; \n values[2] = \n -1.0L / 2.0L * exp(R_x * (-2 * sqrt(25.0 + 4 * pi2) + 10.0)) - \n 2.0 * \n (-6538034.74494422 + \n 0.0134758939981709 * exp(4 * sqrt(25.0 + 4 * pi2))) / \n (-80.0 * exp(3 * sqrt(25.0 + 4 * pi2)) + \n 16.0 * sqrt(25.0 + 4 * pi2) * exp(3 * sqrt(25.0 + 4 * pi2))) - \n 1634508.68623606 * exp(-3.0 * sqrt(25.0 + 4 * pi2)) / \n (-10.0 + 2.0 * sqrt(25.0 + 4 * pi2)) + \n (-0.00673794699908547 * exp(sqrt(25.0 + 4 * pi2)) + \n 3269017.37247211 * exp(-3 * sqrt(25.0 + 4 * pi2))) / \n (-8 * sqrt(25.0 + 4 * pi2) + 40.0) + \n 0.00336897349954273 * exp(1.0 * sqrt(25.0 + 4 * pi2)) / \n (-10.0 + 2.0 * sqrt(25.0 + 4 * pi2)); \n } \n\n// @sect3{The main program} \n\n// 主类与 step-40 非常相似，只是矩阵和向量现在是块状的，而且我们为拥有的和相关的DoF存储一个 std::vector ，而不是一个IndexSet。我们正好有两个IndexSets，一个用于所有速度未知数，一个用于所有压力未知数。\n\n template \n class StokesProblem \n { \n public: \n StokesProblem(unsigned int velocity_degree); \n\n void run(); \n\n private: \n void make_grid(); \n void setup_system(); \n void assemble_system(); \n void solve(); \n void refine_grid(); \n void output_results(const unsigned int cycle) const; \n\n unsigned int velocity_degree; \n double viscosity; \n MPI_Comm mpi_communicator; \n\n FESystem fe; \n parallel::distributed::Triangulation triangulation; \n DoFHandler dof_handler; \n\n std::vector owned_partitioning; \n std::vector relevant_partitioning; \n\n AffineConstraints constraints; \n\n LA::MPI::BlockSparseMatrix system_matrix; \n LA::MPI::BlockSparseMatrix preconditioner_matrix; \n LA::MPI::BlockVector locally_relevant_solution; \n LA::MPI::BlockVector system_rhs; \n\n ConditionalOStream pcout; \n TimerOutput computing_timer; \n }; \n\n template \n StokesProblem::StokesProblem(unsigned int velocity_degree) \n : velocity_degree(velocity_degree) \n , viscosity(0.1) \n , mpi_communicator(MPI_COMM_WORLD) \n , fe(FE_Q(velocity_degree), dim, FE_Q(velocity_degree - 1), 1) \n , triangulation(mpi_communicator, \n typename Triangulation::MeshSmoothing( \n Triangulation::smoothing_on_refinement | \n Triangulation::smoothing_on_coarsening)) \n , dof_handler(triangulation) \n , pcout(std::cout, \n (Utilities::MPI::this_mpi_process(mpi_communicator) == 0)) \n , computing_timer(mpi_communicator, \n pcout, \n TimerOutput::summary, \n TimerOutput::wall_times) \n {} \n\n// Kovasnay流定义在域[-0.5, 1.5]^2上，我们通过将最小和最大值传递给 GridGenerator::hyper_cube. 来创建这个域。\n template \n void StokesProblem::make_grid() \n { \n GridGenerator::hyper_cube(triangulation, -0.5, 1.5); \n triangulation.refine_global(3); \n } \n// @sect3{System Setup} \n\n// 与 step-40 相比，块矩阵和向量的构造是新的，与 step-22 这样的串行代码相比也是不同的，因为我们需要提供属于我们处理器的行的集合。\n\n template \n void StokesProblem::setup_system() \n { \n TimerOutput::Scope t(computing_timer, \"setup\"); \n\n dof_handler.distribute_dofs(fe); \n\n// 将所有的昏暗速度放入0区块，压力放入1区块，然后按区块重新排列未知数。最后计算每块有多少个未知数。\n\n std::vector stokes_sub_blocks(dim + 1, 0); \n stokes_sub_blocks[dim] = 1; \n DoFRenumbering::component_wise(dof_handler, stokes_sub_blocks); \n\n const std::vector dofs_per_block = \n DoFTools::count_dofs_per_fe_block(dof_handler, stokes_sub_blocks); \n\n const unsigned int n_u = dofs_per_block[0]; \n const unsigned int n_p = dofs_per_block[1]; \n\n pcout << \" Number of degrees of freedom: \" << dof_handler.n_dofs() << \" (\" \n << n_u << '+' << n_p << ')' << std::endl; \n\n// 我们根据我们想要创建块状矩阵和向量的方式，将本地拥有的和本地相关的DoF的IndexSet分割成两个IndexSets。\n\n owned_partitioning.resize(2); \n owned_partitioning[0] = dof_handler.locally_owned_dofs().get_view(0, n_u); \n owned_partitioning[1] = \n dof_handler.locally_owned_dofs().get_view(n_u, n_u + n_p); \n\n IndexSet locally_relevant_dofs; \n DoFTools::extract_locally_relevant_dofs(dof_handler, locally_relevant_dofs); \n relevant_partitioning.resize(2); \n relevant_partitioning[0] = locally_relevant_dofs.get_view(0, n_u); \n relevant_partitioning[1] = locally_relevant_dofs.get_view(n_u, n_u + n_p); \n\n// 设置边界条件和悬挂节点的约束与 step-40 相同。尽管我们没有任何悬空节点，因为我们只进行全局细化，但把这个函数调用放进去仍然是个好主意，以备以后引入自适应细化。\n\n { \n constraints.reinit(locally_relevant_dofs); \n\n FEValuesExtractors::Vector velocities(0); \n DoFTools::make_hanging_node_constraints(dof_handler, constraints); \n VectorTools::interpolate_boundary_values(dof_handler, \n 0, \n ExactSolution(), \n constraints, \n fe.component_mask(velocities)); \n constraints.close(); \n } \n\n// 现在我们根据BlockDynamicSparsityPattern来创建系统矩阵。我们知道我们不会有不同速度分量之间的耦合（因为我们使用的是拉普拉斯而不是变形张量），也不会有压力与其测试函数之间的耦合，所以我们使用一个表来将这个耦合信息传达给 DoFTools::make_sparsity_pattern. 。\n { \n system_matrix.clear(); \n\n Table<2, DoFTools::Coupling> coupling(dim + 1, dim + 1); \n for (unsigned int c = 0; c < dim + 1; ++c) \n for (unsigned int d = 0; d < dim + 1; ++d) \n if (c == dim && d == dim) \n coupling[c][d] = DoFTools::none; \n else if (c == dim || d == dim || c == d) \n coupling[c][d] = DoFTools::always; \n else \n coupling[c][d] = DoFTools::none; \n\n BlockDynamicSparsityPattern dsp(dofs_per_block, dofs_per_block); \n\n DoFTools::make_sparsity_pattern( \n dof_handler, coupling, dsp, constraints, false); \n\n SparsityTools::distribute_sparsity_pattern( \n dsp, \n dof_handler.locally_owned_dofs(), \n mpi_communicator, \n locally_relevant_dofs); \n\n system_matrix.reinit(owned_partitioning, dsp, mpi_communicator); \n } \n\n// 先决条件矩阵有不同的耦合（我们只在1,1块中填入质量矩阵），否则这段代码与上面的system_matrix的构造是相同的。\n\n { \n preconditioner_matrix.clear(); \n\n Table<2, DoFTools::Coupling> coupling(dim + 1, dim + 1); \n for (unsigned int c = 0; c < dim + 1; ++c) \n for (unsigned int d = 0; d < dim + 1; ++d) \n if (c == dim && d == dim) \n coupling[c][d] = DoFTools::always; \n else \n coupling[c][d] = DoFTools::none; \n\n BlockDynamicSparsityPattern dsp(dofs_per_block, dofs_per_block); \n\n DoFTools::make_sparsity_pattern( \n dof_handler, coupling, dsp, constraints, false); \n SparsityTools::distribute_sparsity_pattern( \n dsp, \n Utilities::MPI::all_gather(mpi_communicator, \n dof_handler.locally_owned_dofs()), \n mpi_communicator, \n locally_relevant_dofs); \n preconditioner_matrix.reinit(owned_partitioning, \n\n// owned_partitioning。\n\n dsp, \n mpi_communicator); \n } \n\n// 最后，我们以正确的尺寸构建块状向量。带有两个 std::vector 的函数调用将创建一个重影向量。\n\n locally_relevant_solution.reinit(owned_partitioning, \n relevant_partitioning, \n mpi_communicator); \n system_rhs.reinit(owned_partitioning, mpi_communicator); \n } \n\n// @sect3{Assembly} \n\n// 这个函数将系统矩阵、预处理矩阵和右手边集合起来。其代码非常标准。\n\n template \n void StokesProblem::assemble_system() \n { \n TimerOutput::Scope t(computing_timer, \"assembly\"); \n\n system_matrix = 0; \n preconditioner_matrix = 0; \n system_rhs = 0; \n\n const QGauss quadrature_formula(velocity_degree + 1); \n\n FEValues fe_values(fe, \n quadrature_formula, \n update_values | update_gradients | \n update_quadrature_points | update_JxW_values); \n\n const unsigned int dofs_per_cell = fe.n_dofs_per_cell(); \n const unsigned int n_q_points = quadrature_formula.size(); \n\n FullMatrix cell_matrix(dofs_per_cell, dofs_per_cell); \n FullMatrix cell_matrix2(dofs_per_cell, dofs_per_cell); \n Vector cell_rhs(dofs_per_cell); \n\n const RightHandSide right_hand_side; \n std::vector> rhs_values(n_q_points, Vector(dim + 1)); \n\n std::vector> grad_phi_u(dofs_per_cell); \n std::vector div_phi_u(dofs_per_cell); \n std::vector phi_p(dofs_per_cell); \n\n std::vector local_dof_indices(dofs_per_cell); \n const FEValuesExtractors::Vector velocities(0); \n const FEValuesExtractors::Scalar pressure(dim); \n\n for (const auto &cell : dof_handler.active_cell_iterators()) \n if (cell->is_locally_owned()) \n { \n cell_matrix = 0; \n cell_matrix2 = 0; \n cell_rhs = 0; \n\n fe_values.reinit(cell); \n right_hand_side.vector_value_list(fe_values.get_quadrature_points(), \n rhs_values); \n for (unsigned int q = 0; q < n_q_points; ++q) \n { \n for (unsigned int k = 0; k < dofs_per_cell; ++k) \n { \n grad_phi_u[k] = fe_values[velocities].gradient(k, q); \n div_phi_u[k] = fe_values[velocities].divergence(k, q); \n phi_p[k] = fe_values[pressure].value(k, q); \n } \n\n for (unsigned int i = 0; i < dofs_per_cell; ++i) \n { \n for (unsigned int j = 0; j < dofs_per_cell; ++j) \n { \n cell_matrix(i, j) += \n (viscosity * \n scalar_product(grad_phi_u[i], grad_phi_u[j]) - \n div_phi_u[i] * phi_p[j] - phi_p[i] * div_phi_u[j]) * \n fe_values.JxW(q); \n\n cell_matrix2(i, j) += 1.0 / viscosity * phi_p[i] * \n phi_p[j] * fe_values.JxW(q); \n } \n\n const unsigned int component_i = \n fe.system_to_component_index(i).first; \n cell_rhs(i) += fe_values.shape_value(i, q) * \n rhs_values[q](component_i) * fe_values.JxW(q); \n } \n } \n\n cell->get_dof_indices(local_dof_indices); \n constraints.distribute_local_to_global(cell_matrix, \n cell_rhs, \n local_dof_indices, \n system_matrix, \n system_rhs); \n\n constraints.distribute_local_to_global(cell_matrix2, \n local_dof_indices, \n preconditioner_matrix); \n } \n\n system_matrix.compress(VectorOperation::add); \n preconditioner_matrix.compress(VectorOperation::add); \n system_rhs.compress(VectorOperation::add); \n } \n\n// @sect3{Solving} \n\n// 这个函数用MINRES求解线性系统，如介绍中所述，对两个对角线块使用块状对角线预处理和AMG。预处理程序对0,0块应用v循环，对1,1块应用质量矩阵的CG（Schur补充）。\n\n template \n void StokesProblem::solve() \n { \n TimerOutput::Scope t(computing_timer, \"solve\"); \n\n LA::MPI::PreconditionAMG prec_A; \n { \n LA::MPI::PreconditionAMG::AdditionalData data; \n\n#ifdef USE_PETSC_LA \n data.symmetric_operator = true; \n#endif \n prec_A.initialize(system_matrix.block(0, 0), data); \n } \n\n LA::MPI::PreconditionAMG prec_S; \n { \n LA::MPI::PreconditionAMG::AdditionalData data; \n\n#ifdef USE_PETSC_LA \n data.symmetric_operator = true; \n#endif \n prec_S.initialize(preconditioner_matrix.block(1, 1), data); \n } \n\n// InverseMatrix用于解决质量矩阵的问题。\n\n using mp_inverse_t = LinearSolvers::InverseMatrix; \n const mp_inverse_t mp_inverse(preconditioner_matrix.block(1, 1), prec_S); \n\n// 这是在上面定义的各个块的预处理的基础上构造的块预处理。\n\n const LinearSolvers::BlockDiagonalPreconditioner \n preconditioner(prec_A, mp_inverse); \n\n// 有了这些，我们终于可以设置线性求解器并求解该系统。\n\n SolverControl solver_control(system_matrix.m(), \n 1e-10 * system_rhs.l2_norm()); \n\n SolverMinRes solver(solver_control); \n\n LA::MPI::BlockVector distributed_solution(owned_partitioning, \n mpi_communicator); \n\n constraints.set_zero(distributed_solution); \n\n solver.solve(system_matrix, \n distributed_solution, \n system_rhs, \n preconditioner); \n\n pcout << \" Solved in \" << solver_control.last_step() << \" iterations.\" \n << std::endl; \n\n constraints.distribute(distributed_solution); \n\n// 像在 step-56 中一样，我们减去平均压力，以便与我们的参考解决方案进行误差计算，该解决方案的平均值为零。\n\n locally_relevant_solution = distributed_solution; \n const double mean_pressure = \n VectorTools::compute_mean_value(dof_handler, \n QGauss(velocity_degree + 2), \n locally_relevant_solution, \n dim); \n distributed_solution.block(1).add(-mean_pressure); \n locally_relevant_solution.block(1) = distributed_solution.block(1); \n } \n\n// @sect3{The rest} \n\n// 其余处理网格细化、输出和主循环的代码非常标准。\n\n template \n void StokesProblem::refine_grid() \n { \n TimerOutput::Scope t(computing_timer, \"refine\"); \n\n triangulation.refine_global(); \n } \n\n template \n void StokesProblem::output_results(const unsigned int cycle) const \n { \n { \n const ComponentSelectFunction pressure_mask(dim, dim + 1); \n const ComponentSelectFunction velocity_mask(std::make_pair(0, dim), \n dim + 1); \n\n Vector cellwise_errors(triangulation.n_active_cells()); \n QGauss quadrature(velocity_degree + 2); \n\n VectorTools::integrate_difference(dof_handler, \n locally_relevant_solution, \n ExactSolution(), \n cellwise_errors, \n quadrature, \n VectorTools::L2_norm, \n &velocity_mask); \n\n const double error_u_l2 = \n VectorTools::compute_global_error(triangulation, \n cellwise_errors, \n VectorTools::L2_norm); \n\n VectorTools::integrate_difference(dof_handler, \n locally_relevant_solution, \n ExactSolution(), \n cellwise_errors, \n quadrature, \n VectorTools::L2_norm, \n &pressure_mask); \n\n const double error_p_l2 = \n VectorTools::compute_global_error(triangulation, \n cellwise_errors, \n VectorTools::L2_norm); \n\n pcout << \"error: u_0: \" << error_u_l2 << \" p_0: \" << error_p_l2 \n << std::endl; \n } \n\n std::vector solution_names(dim, \"velocity\"); \n solution_names.emplace_back(\"pressure\"); \n std::vector \n data_component_interpretation( \n dim, DataComponentInterpretation::component_is_part_of_vector); \n data_component_interpretation.push_back( \n DataComponentInterpretation::component_is_scalar); \n\n DataOut data_out; \n data_out.attach_dof_handler(dof_handler); \n data_out.add_data_vector(locally_relevant_solution, \n solution_names, \n DataOut::type_dof_data, \n data_component_interpretation); \n\n LA::MPI::BlockVector interpolated; \n interpolated.reinit(owned_partitioning, MPI_COMM_WORLD); \n VectorTools::interpolate(dof_handler, ExactSolution(), interpolated); \n\n LA::MPI::BlockVector interpolated_relevant(owned_partitioning, \n relevant_partitioning, \n MPI_COMM_WORLD); \n interpolated_relevant = interpolated; \n { \n std::vector solution_names(dim, \"ref_u\"); \n solution_names.emplace_back(\"ref_p\"); \n data_out.add_data_vector(interpolated_relevant, \n solution_names, \n DataOut::type_dof_data, \n data_component_interpretation); \n } \n\n Vector subdomain(triangulation.n_active_cells()); \n for (unsigned int i = 0; i < subdomain.size(); ++i) \n subdomain(i) = triangulation.locally_owned_subdomain(); \n data_out.add_data_vector(subdomain, \"subdomain\"); \n\n data_out.build_patches(); \n\n data_out.write_vtu_with_pvtu_record( \n \"./\", \"solution\", cycle, mpi_communicator, 2); \n } \n\n template \n void StokesProblem::run() \n { \n#ifdef USE_PETSC_LA \n pcout << \"Running using PETSc.\" << std::endl; \n#else \n pcout << \"Running using Trilinos.\" << std::endl; \n#endif \n const unsigned int n_cycles = 5; \n for (unsigned int cycle = 0; cycle < n_cycles; ++cycle) \n { \n pcout << \"Cycle \" << cycle << ':' << std::endl; \n\n if (cycle == 0) \n make_grid(); \n else \n refine_grid(); \n\n setup_system(); \n\n assemble_system(); \n solve(); \n\n if (Utilities::MPI::n_mpi_processes(mpi_communicator) <= 32) \n { \n TimerOutput::Scope t(computing_timer, \"output\"); \n output_results(cycle); \n } \n\n computing_timer.print_summary(); \n computing_timer.reset(); \n\n pcout << std::endl; \n } \n } \n} // namespace Step55 \n\nint main(int argc, char *argv[]) \n{ \n try \n { \n using namespace dealii; \n using namespace Step55; \n\n Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1); \n\n StokesProblem<2> problem(2); \n problem.run(); \n } \n catch (std::exception &exc) \n { \n std::cerr << std::endl \n << std::endl \n << \"----------------------------------------------------\" \n << std::endl; \n std::cerr << \"Exception on processing: \" << std::endl \n << exc.what() << std::endl \n << \"Aborting!\" << std::endl \n << \"----------------------------------------------------\" \n << std::endl; \n\n return 1; \n } \n catch (...) \n { \n std::cerr << std::endl \n << std::endl \n << \"----------------------------------------------------\" \n << std::endl; \n std::cerr << \"Unknown exception!\" << std::endl \n << \"Aborting!\" << std::endl \n << \"----------------------------------------------------\" \n << std::endl; \n return 1; \n } \n\n return 0; \n} \n\n", "meta": {"hexsha": "63437a9c8c05b146e8c17f6f04e3c79271c62f1d", "size": 27258, "ext": "cc", "lang": "C++", "max_stars_repo_path": "Translator_file/examples/step-55/step-55.cc", "max_stars_repo_name": "jiaqiwang969/deal.ii-course-practice", "max_stars_repo_head_hexsha": "0da5ad1537d8152549d8a0e4de5872efe7619c8a", "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": "Translator_file/examples/step-55/step-55.cc", "max_issues_repo_name": "jiaqiwang969/deal.ii-course-practice", "max_issues_repo_head_hexsha": "0da5ad1537d8152549d8a0e4de5872efe7619c8a", "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": "Translator_file/examples/step-55/step-55.cc", "max_forks_repo_name": "jiaqiwang969/deal.ii-course-practice", "max_forks_repo_head_hexsha": "0da5ad1537d8152549d8a0e4de5872efe7619c8a", "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.5475285171, "max_line_length": 161, "alphanum_fraction": 0.572088928, "num_tokens": 7816, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428946, "lm_q2_score": 0.760650658103136, "lm_q1q2_score": 0.5993403825057586}} {"text": "/*\n * Copyright 2017 Mahdi Khanalizadeh\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\n#ifndef HEADER_EXT_VECTOR3_HPP_INCLUDED\n#define HEADER_EXT_VECTOR3_HPP_INCLUDED\n\n#include \n\n#include \n\nnamespace ext\n{\n\n\ttemplate \n\tclass Vector3 :\n\t\tboost::equality_comparable,\n\t\tboost::additive,\n\t\tboost::multiplicative, T\n\t\t>>>\n\t{\n\tpublic:\n\t\tusing Type = T;\n\n\t\tType x;\n\t\tType y;\n\t\tType z;\n\n\t\tVector3() : x{0}, y{0}, z{0} {}\n\t\tVector3(Type x_, Type y_, Type z_) : x{x_}, y{y_}, z{z_} {}\n\t\ttemplate \n\t\tVector3(Vector3 const& v) : x{v.x}, y{v.y}, z{v.z} {}\n\t};\n\n\tusing Vector3f = Vector3;\n\tusing Vector3d = Vector3;\n\tusing Vector3ld = Vector3;\n\n\ttemplate \n\tbool operator==(Vector3 const& v1, Vector3 const& v2)\n\t{\n\t\treturn v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;\n\t}\n\n\ttemplate \n\tVector3& operator+=(Vector3& v1, Vector3 const& v2)\n\t{\n\t\tv1.x += v2.x;\n\t\tv1.y += v2.y;\n\t\tv1.z += v2.z;\n\t\treturn v1;\n\t}\n\n\ttemplate \n\tVector3& operator-=(Vector3& v1, Vector3 const& v2)\n\t{\n\t\tv1.x -= v2.x;\n\t\tv1.y -= v2.y;\n\t\tv1.z -= v2.z;\n\t\treturn v1;\n\t}\n\n\ttemplate \n\tVector3& operator*=(Vector3& v, T t)\n\t{\n\t\tv.x *= t;\n\t\tv.y *= t;\n\t\tv.z *= t;\n\t\treturn v;\n\t}\n\n\ttemplate \n\tVector3& operator/=(Vector3& v, T t)\n\t{\n\t\tv.x /= t;\n\t\tv.y /= t;\n\t\tv.z /= t;\n\t\treturn v;\n\t}\n\n\ttemplate \n\tVector3 operator+(Vector3 const& v)\n\t{\n\t\treturn v;\n\t}\n\n\ttemplate \n\tVector3 operator-(Vector3 const& v)\n\t{\n\t\treturn {-v.x, -v.y, -v.z};\n\t}\n\n\ttemplate \n\tT dot(Vector3 const& v1, Vector3 const& v2)\n\t{\n\t\treturn v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;\n\t}\n\n\ttemplate \n\tT norm(Vector3 const& v)\n\t{\n\t\treturn std::sqrt(dot(v, v));\n\t}\n\n\ttemplate \n\tVector3 normalize(Vector3 const& v)\n\t{\n\t\treturn v / norm(v);\n\t}\n\n} // namespace ext\n\n#endif // !HEADER_EXT_VECTOR3_HPP_INCLUDED\n", "meta": {"hexsha": "b91c49587d3e5a831c72153485cfe17d4592a75a", "size": 2525, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/ext/vector3.hpp", "max_stars_repo_name": "Biolunar/ext", "max_stars_repo_head_hexsha": "2035c73a1abae89a392dc75d0228c200d05387d9", "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": "include/ext/vector3.hpp", "max_issues_repo_name": "Biolunar/ext", "max_issues_repo_head_hexsha": "2035c73a1abae89a392dc75d0228c200d05387d9", "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/ext/vector3.hpp", "max_forks_repo_name": "Biolunar/ext", "max_forks_repo_head_hexsha": "2035c73a1abae89a392dc75d0228c200d05387d9", "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": 20.0396825397, "max_line_length": 75, "alphanum_fraction": 0.636039604, "num_tokens": 809, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506418255927, "lm_q2_score": 0.7879311906630568, "lm_q1q2_score": 0.5993403658922577}} {"text": "// system includes -----------------------------------------------\n#include \n#include \n#include \n// own includes --------------------------------------------------\n#include \n#include \n#include \n#include \n#include \n#include \n\nusing namespace std;\n\nconst char* fname = \"test_rt.h5\";\n\n// typedef FFTr2c fft_t;\ntypedef FFT fft_t;\ntypedef RT, RidgeletFrame, fft_t> RT_t;\ntypedef RT_t::array_t array_t;\ntypedef RT_t::complex_array_t complex_array_t;\ntypedef RT_t::rt_coeff_t rt_coeff_t;\n\nvoid dump_frc(const std::vector& f_rc, const RidgeletFrame& rt)\n{\n const char* fname = \"f_rc.h5\";\n hid_t file = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);\n for (unsigned int i = 0; i < f_rc.size(); ++i) {\n stringstream ss;\n ss << rt.lambdas()[i];\n string slam = ss.str();\n eigen2hdf::save(file, slam, f_rc[i]);\n }\n H5Fclose(file);\n cout << \"Written f(lambda, t) to \" << fname << \"\\n\";\n}\n\nint main(int argc, char* argv[])\n{\n SOURCE_INFO();\n\n namespace po = boost::program_options;\n\n unsigned int Jx, Jy, rho_x, rho_y;\n\n po::options_description options(\"options\");\n options.add_options()\n (\"help\", \"produce help message\")\n (\"Jx,i\", po::value(&Jx)->default_value(3), \"Jx\")\n (\"Jy,j\", po::value(&Jy)->default_value(3), \"Jy\")\n (\"rx,x\", po::value(&rho_x)->default_value(1), \"rho_x\")\n (\"ry,y\", po::value(&rho_y)->default_value(1), \"rho_x\")\n (\"save\", \"save coefficients\");\n po::variables_map vm;\n po::store(po::parse_command_line(argc, argv, options), vm);\n po::notify(vm);\n\n if (vm.count(\"help\")) {\n std::cout << options << \"\\n\";\n return 0;\n }\n\n cout << setw(20) << \"Jx: \" << Jx << \"\\n\"\n << setw(20) << \"Jy: \" << Jy << \"\\n\"\n << setw(20) << \"rho_x: \" << rho_x << \"\\n\"\n << setw(20) << \"rho_y: \" << rho_y << \"\\n\"\n << setw(20) << \"Nx: \" << std::pow(2, Jx + 2) * rho_x << \"\\n\"\n << setw(20) << \"Ny: \" << std::pow(2, Jy + 2) * rho_y << \"\\n\";\n RDTSCTimer timer;\n\n timer.start();\n RidgeletFrame frame(Jx, Jy, rho_x, rho_y);\n double time_frame_constructor = timer.stop();\n timer.print(cout, time_frame_constructor, \"RidgeletFrame init\");\n\n const unsigned int ncols = frame.Nx(); // #cols\n const unsigned int nrows = frame.Ny(); // #rows\n\n RT_t rt(frame);\n array_t F(nrows / 2, ncols / 2);\n {\n double pi = boost::math::constants::pi();\n Eigen::ArrayXd x = pi * Eigen::ArrayXd::LinSpaced(ncols / 2, 0, 1);\n Eigen::ArrayXd y = pi * Eigen::ArrayXd::LinSpaced(nrows / 2, 0, 1);\n F = y.replicate(1, x.rows()).sin() * x.transpose().replicate(y.rows(), 1).sin();\n\n Eigen::MatrixXd tmp = F;\n tmp = tmp.triangularView();\n F = tmp.array();\n }\n\n fft_t fft;\n // debug\n complex_array_t Fhh(nrows / 2, ncols / 2);\n fft.ft(Fhh, F, false);\n hid_t file;\n if (vm.count(\"save\")) {\n file = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);\n eigen2hdf::save(file, \"Fhh\", Fhh); // debug\n }\n // ----------------------------------------\n complex_array_t Fh(nrows, ncols);\n Fh.setZero();\n ftcut(Fh, nrows / 2, ncols / 2) = Fhh;\n std::vector rt_coeffs(frame.size());\n timer.start();\n cout << \"rt.rt(...)\"\n << \"\\n\";\n rt.rt(rt_coeffs, Fh);\n\n int ncoeffs = 0;\n for (unsigned int i = 0; i < rt_coeffs.size(); ++i) {\n ncoeffs += rt_coeffs[i].rows() * rt_coeffs[i].cols();\n }\n cout << \"dim(rt_coeffs): \" << ncoeffs << \"\\n\";\n auto time_rt = timer.stop();\n timer.print(cout, time_rt, \"rt.rt\");\n\n // -------------------- Inverse transform --------------------\n complex_array_t Fh2(nrows, ncols);\n timer.start();\n cout << \"rt.irt(...)\"\n << \"\\n\";\n rt.irt(Fh2, rt_coeffs);\n auto time_irt = timer.stop();\n timer.print(cout, time_irt, \"rt.irt\");\n\n array_t F2(nrows / 2, ncols / 2);\n complex_array_t Fh2_cut(nrows / 2, ncols / 2);\n Fh2_cut.setZero();\n Fh2_cut = ftcut(Fh2, nrows / 2, ncols / 2);\n fft.ift(F2, Fh2_cut);\n auto diff = (F - F2).abs();\n cout << \"(F-F2).abs().sum(): \" << diff.sum() << \"\\n\";\n\n if (vm.count(\"save\")) {\n eigen2hdf::save(file, \"Fhl\", Fhh);\n eigen2hdf::save(file, \"Fh\", Fh);\n eigen2hdf::save(file, \"R\", F);\n eigen2hdf::save(file, \"Fh2\", Fh2);\n eigen2hdf::save(file, \"R2\", F2);\n H5Fclose(file);\n cout << \"written results to \" << fname << \"\\n\";\n }\n\n return 0;\n}\n", "meta": {"hexsha": "21c1bc0726168a7d18b4718fd8f6a2dbd10083c3", "size": 4562, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "test/main_test_rt.cpp", "max_stars_repo_name": "simonpp/2dRidgeletBTE", "max_stars_repo_head_hexsha": "5d08cbb5c57fc276c7a528f128615d23c37ef6a0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-11-08T03:15:56.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-08T03:15:56.000Z", "max_issues_repo_path": "test/main_test_rt.cpp", "max_issues_repo_name": "simonpp/2dRidgeletBTE", "max_issues_repo_head_hexsha": "5d08cbb5c57fc276c7a528f128615d23c37ef6a0", "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": "test/main_test_rt.cpp", "max_forks_repo_name": "simonpp/2dRidgeletBTE", "max_forks_repo_head_hexsha": "5d08cbb5c57fc276c7a528f128615d23c37ef6a0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2019-11-08T03:15:56.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-08T03:15:56.000Z", "avg_line_length": 30.8243243243, "max_line_length": 84, "alphanum_fraction": 0.5795703639, "num_tokens": 1469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240756264638, "lm_q2_score": 0.6926419958239132, "lm_q1q2_score": 0.5992905305768143}} {"text": "#include \"Geometry.h\"\n\n\n#include \"Eigen/Core\"\n#include \"Eigen/Dense\"\n//#include \n\n#include \"glm/glm.hpp\"\n#include \"glm/gtc/matrix_transform.hpp\"\n#include \"glm/gtc/matrix_access.hpp\"\n\n\n#include \n#include \n\n\n#define MIN_VAL -FLT_MAX\n#define MAX_VAL FLT_MAX\n\n\nusing namespace Eigen;\n\n\nvoid ComputeSpatialProperties(std::vector* verts) {\n\tconst int numVerts = ((int)verts->size()) / 3;\n\tglm::vec3 minPoint(MIN_VAL, MIN_VAL, MIN_VAL);\n\tglm::vec3 maxPoint(MAX_VAL, MAX_VAL, MAX_VAL);\n\tglm::vec3 centroid(0.0f);\n\n\tMatrixXf A(numVerts, 3);\n\n\tfor (int i = 0; i < numVerts; i++) {\n\n\t\tfloat x = (*verts)[i * 3];\n\t\tfloat y = (*verts)[i * 3 + 1];\n\t\tfloat z = (*verts)[i * 3 + 2];\n\t\tif (x > minPoint.x) { minPoint.x = x; }\n\t\tif (y > minPoint.y) { minPoint.y = y; }\n\t\tif (z > minPoint.z) { minPoint.z = z; }\n\n\t\tcentroid.x += x;\n\t\tcentroid.y += y;\n\t\tcentroid.z += z;\n\n\t\tA.row(i) << x, y, z;\n\t}\n\n\t//https://stats.stackexchange.com/questions/134282/relationship-between-svd-and-pca-how-to-use-svd-to-perform-pca\n\t//std::cout << A << std::endl;\n\n\tJacobiSVD svd(A, ComputeThinV);\n\tstd::cout << \"Its singular values are:\" << std::endl << svd.singularValues() << std::endl;\n\tstd::cout << \"Its right singular vectors are the columns of the thin V matrix:\" << std::endl << svd.matrixV() << std::endl;\n\tint ti = 1;\n\n\n\n\n\n}\n\n\n", "meta": {"hexsha": "26bd82e6242b6a3844f70afaf9be2457016dde69", "size": 1345, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "OpenGL/src/geometry/Geometry.cpp", "max_stars_repo_name": "ScottMoisik/OpenGL", "max_stars_repo_head_hexsha": "e26c73fabfc419d7feaa4215c635244149c8e9c5", "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": "OpenGL/src/geometry/Geometry.cpp", "max_issues_repo_name": "ScottMoisik/OpenGL", "max_issues_repo_head_hexsha": "e26c73fabfc419d7feaa4215c635244149c8e9c5", "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": "OpenGL/src/geometry/Geometry.cpp", "max_forks_repo_name": "ScottMoisik/OpenGL", "max_forks_repo_head_hexsha": "e26c73fabfc419d7feaa4215c635244149c8e9c5", "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": 21.3492063492, "max_line_length": 124, "alphanum_fraction": 0.6408921933, "num_tokens": 427, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240686758841, "lm_q2_score": 0.6926419767901475, "lm_q1q2_score": 0.5992905092940787}} {"text": "/**\n * @file finitevolumerobin_main.cc\n * @brief NPDE homework FiniteVolumeRobin code\n * @author Philippe Peter\n * @date February 2020\n * @copyright Developed at ETH Zurich\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"finitevolumerobin.h\"\n\nint main() {\n // coefficient functions\n auto g = [](const Eigen::Vector2d & /*x*/) { return 1.0; };\n auto gamma = [](const Eigen::Vector2d &x) { return 1.0 + x(0) * x(0); };\n\n // The equation is solved on the four test meshes\n // disk1.msh, disk2.msh, disk3.msh and disk4.msh\n for (int i = 1; i <= 4; ++i) {\n // read mesh\n auto mesh_factory = std::make_unique(2);\n lf::io::GmshReader reader(\n std::move(mesh_factory),\n CURRENT_SOURCE_DIR \"/../meshes/disk\" + std::to_string(i) + \".msh\");\n auto mesh_p = reader.mesh();\n\n // Construct dofhanlder for linear finite elements on the current mesh.\n auto fe_space =\n std::make_shared>(mesh_p);\n const lf::assemble::DofHandler &dofh{fe_space->LocGlobMap()};\n\n // Create a dataset of boolean flags indicating edges on the boundary of the\n // mesh\n auto bd_flags{lf::mesh::utils::flagEntitiesOnBoundary(mesh_p, 1)};\n\n // ASSEMBLE GALERKIN MATRIX\n // Matrix in triplet format holding Galerkin matrix, zero initially.\n lf::assemble::COOMatrix A(dofh.NumDofs(), dofh.NumDofs());\n\n // First the part corresponding to piecewise Lagrangian finite elements\n lf::uscalfe::LinearFELaplaceElementMatrix elmat_provider;\n lf::assemble::AssembleMatrixLocally(0, dofh, dofh, elmat_provider, A);\n\n // Next the part corresponding to the modifications of the Galerkin matrix\n // on the boundary.\n FiniteVolumeRobin::EdgeMatrixProvider edmat_provider(gamma, bd_flags);\n lf::assemble::AssembleMatrixLocally(1, dofh, dofh, edmat_provider, A);\n\n // RIGHT-HAND SIDE VECTOR\n Eigen::VectorXd phi(dofh.NumDofs());\n phi.setZero();\n\n // Contributions on the boundary to the rhs vector\n FiniteVolumeRobin::EdgeVectorProvider edvec_provider(g, bd_flags);\n lf::assemble::AssembleVectorLocally(1, dofh, edvec_provider, phi);\n\n // SOLVE LINEAR SYSTEM\n Eigen::SparseMatrix A_crs = A.makeSparse();\n Eigen::SparseLU> solver;\n solver.compute(A_crs);\n Eigen::VectorXd sol_vec = solver.solve(phi);\n\n // OUTPUT RESULTS TO VTK FILE\n // construct mesh function representing the finite element solution\n lf::uscalfe::MeshFunctionFE mf_sol(fe_space, sol_vec);\n // construct vtk writer\n lf::io::VtkWriter vtk_writer(mesh_p, CURRENT_BINARY_DIR\n \"/finite_volume_robin_solution_\" +\n std::to_string(i) + \".vtk\");\n // output data\n vtk_writer.WritePointData(\n \"finite_volume_robin_solution_\" + std::to_string(i), mf_sol);\n }\n return 0;\n}\n", "meta": {"hexsha": "4b1525a12fac1bdf6d7e370109eb5e0580b61096", "size": 3205, "ext": "cc", "lang": "C++", "max_stars_repo_path": "homeworks/FiniteVolumeRobin/templates/finitevolumerobin_main.cc", "max_stars_repo_name": "padomu/NPDECODES", "max_stars_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "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": "homeworks/FiniteVolumeRobin/templates/finitevolumerobin_main.cc", "max_issues_repo_name": "padomu/NPDECODES", "max_issues_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "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": "homeworks/FiniteVolumeRobin/templates/finitevolumerobin_main.cc", "max_forks_repo_name": "padomu/NPDECODES", "max_forks_repo_head_hexsha": "d2bc5b0d2d5e76e4d5b8ab6948c82f902211182e", "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.0112359551, "max_line_length": 80, "alphanum_fraction": 0.6811232449, "num_tokens": 866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.826711776992821, "lm_q2_score": 0.7248702821204019, "lm_q1q2_score": 0.599258799021045}} {"text": "#include \n#include \n#include \n#include \"plane3d.hpp\"\n\nusing namespace Eigen;\nusing namespace std;\n\nPlane3d::Plane3d(int _id, double alpha, double theta, Vector3d _target){\n id = _id;\n Vector3d u0(1, 0, 0);\n Vector3d v0(0, cos(alpha), sin(alpha));\n Vector3d w0(0, -sin(alpha), cos(alpha));\n\n Matrix3f rotationX;\n rotationX << u0[0], u0[1], u0[2],\n\t\t v0[0], v0[1], v0[2],\n\t\t w0[0], w0[1], w0[2];\n\n\n Vector3d u1(cos(theta), 0, sin(theta));\n Vector3d v1(0, 1, 0);\n Vector3d w1(-sin(theta), 0, cos(theta));\n\n Matrix3f rotationY;\n rotationY << u1[0], u1[1], u1[2],\n\t\t v1[0], v1[1], v1[2],\n\t\t w1[0], w1[1], w1[2];\n\n\n Matrix3f rotation = rotationX * rotationY;\n\n axisX = Vector3d(rotation.row(0)[0], rotation.row(0)[1], rotation.row(0)[2]);\n axisY = Vector3d(rotation.row(1)[0], rotation.row(1)[1], rotation.row(1)[2]);\n normal = Vector3d(rotation.row(2)[0], rotation.row(2)[1], rotation.row(2)[2]);\n\n Matrix3d A;\n A << axisX[0], axisX[1], axisX[2],\n\t axisY[0], axisY[1], axisY[2],\n\t normal[0], normal[1], normal[2];\n inverse = A.inverse();\n\n\n target = _target;\n}\n\nbool Plane3d::intersectsEdge(Vector3d v0, Vector3d v1){\n Vector3d diffVec0 = v0 - target;\n double dotProduct0 = diffVec0.dot(normal);\n\n Vector3d diffVec1 = v1 - target;\t \n double dotProduct1 = diffVec1.dot(normal);\n\n return dotProduct0 * dotProduct1 < 0;\n}\n\n\nbool Plane3d::containsPoint(Vector3d v0){\n Vector3d diffVec0 = v0 - target;\n double dotProduct0 = diffVec0.dot(normal);\n return dotProduct0 == 0;\n}\n\n\narray Plane3d::findIntersection(Vector3d v0, Vector3d v1){\n Vector3d w = v0 - target;\n Vector3d u = v1 - v0;\n\n double N = -(normal.dot(w));\n double D = normal.dot(u);\n\n array coords3d = {v0[0] + (N/D) * u[0], v0[1] + (N/D) * u[1], v0[2] + (N/D) * u[2]};\n\n return coords3d;\n}\n\nint Plane3d::Id(){\n return id;\n}\n\nVector2d Plane3d::Rotate(array _vec){\n Vector3d vec(_vec[0], _vec[1], _vec[2]);\n double xCoord = axisX.dot(vec - target);\n double yCoord = axisY.dot(vec - target);\n\n return Vector2d(xCoord, yCoord);\n}\n\nVector3d Plane3d::Get3dPoint(Vector3d pt2d){\n double x=pt2d[0]*inverse.row(0)[0] + pt2d[1]*inverse.row(0)[1];\n double y=pt2d[0]*inverse.row(1)[0] + pt2d[1]*inverse.row(1)[1];\n double z=pt2d[0]*inverse.row(2)[0] + pt2d[1]*inverse.row(2)[1];\n Vector3d pt(x + target[0], y + target[1], z + target[2]);\n return pt;\n}\n\n\nShape3d::Shape3d(unsigned long int _tetId, vector> _vertices, double _weight, int _label){\n tetId = _tetId;\n vertices = _vertices;\n weight = _weight;\n label = _label;\n}\n\nunsigned long int Shape3d::TetId(){\n return tetId;\n}\n\nvector> Shape3d::Vertices(){\n //return Vector3d(vertices[0], vertices[1], vertices[2]);\n //vector verticesAsVecs;\n\n //for(int i=0; i<\n return vertices;\n}\n\ndouble Shape3d::Weight(){\n return weight;\n}\n\nint Shape3d::Label(){\n return label;\n}\n", "meta": {"hexsha": "2252c8c6f3c6bc48da438e57ba15ab294da6e9fc", "size": 3026, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "src/plane3d.cpp", "max_stars_repo_name": "myociss/pathfinder", "max_stars_repo_head_hexsha": "4c0b14e074cfc8f0e41836abc056989f2d465c12", "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/plane3d.cpp", "max_issues_repo_name": "myociss/pathfinder", "max_issues_repo_head_hexsha": "4c0b14e074cfc8f0e41836abc056989f2d465c12", "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/plane3d.cpp", "max_forks_repo_name": "myociss/pathfinder", "max_forks_repo_head_hexsha": "4c0b14e074cfc8f0e41836abc056989f2d465c12", "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": 24.4032258065, "max_line_length": 107, "alphanum_fraction": 0.6226040978, "num_tokens": 1074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297914570318, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.5992220317015754}} {"text": "/*\nCopyright (c) 2015, Tianwei Shen\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\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\n* Neither the name of libvot nor the names of its\n contributors may be used to endorse or promote products derived from\n this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/** \\file euclidean_matrix.cpp\n *\t\\brief euclidean matrix completion (exe)\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n\nusing namespace std;\n\n/**\n * @brief An ad-hoc simple 2d point struct\n */\nnamespace {\nstruct point2d\n{\n\tfloat x,y;\n};\n}\t// end of namespace vot\n\nfloat EuclideanDistance(point2d x1, point2d x2)\n{\n\treturn (x1.x - x2.x) * (x1.x - x2.x) + (x1.y - x2.y) * (x1.y - x2.y);\n}\n\nint main(int argc, char **argv)\n{\n\tint input_size;\n\tcout << \"the size of the matrix: \\n\";\n\tcin >> input_size;\n\tconst int MATRIX_SIZE = input_size;\n\tstring matrix_filename = \"euclidean_matrix\";\n\tstringstream ss;\n\tss << matrix_filename << \"_\" << MATRIX_SIZE;\n\tss >> matrix_filename;\n\tFILE *matrix_file = fopen(matrix_filename.c_str(), \"w\");\n\n\tstd::vector points(MATRIX_SIZE);\n\tfor (int i = 0; i < MATRIX_SIZE; i++) {\n\t\tpoints[i].x = rand() % 1000;\n\t\tpoints[i].x /= 1000;\n\t\tpoints[i].y = rand() % 1000;\n\t\tpoints[i].y /= 1000;\n\t}\n\n\tEigen::MatrixXf distance_matrix(MATRIX_SIZE, MATRIX_SIZE);\n\tfor (int i = 0; i < MATRIX_SIZE; i++) {\n\t\tdistance_matrix(i, i) = 0.0;\n\t\tfor (int j = i+1; j < MATRIX_SIZE; j++) {\n\t\t\tdistance_matrix(i, j) = EuclideanDistance(points[i], points[j]);\n\t\t\tdistance_matrix(j, i) = distance_matrix(i, j);\n\t\t}\n\t}\n\n\t// output to the file\n\tfor (int i = 0; i < MATRIX_SIZE; i++) {\n\t\tfor (int j = 0; j < MATRIX_SIZE; j++) {\n\t\t\tcout << distance_matrix(i, j) << \" \";\n\t\t\tfprintf(matrix_file, \"%f \", distance_matrix(i, j));\n\t\t}\n\t\tcout << endl;\n\t\tfprintf(matrix_file, \"\\n\");\n\t}\n\n\tEigen::FullPivLU lu_decomp(distance_matrix);\n\t//lu_decomp.setThreshold(1e-5);\n\tcout << \"rank of distance matrix: \" << lu_decomp.rank() << endl;\n\n\t//Eigen::JacobiSVD svd(distance_matrix, Eigen::ComputeThinU | Eigen::ComputeThinV);\n\t//cout << svd.singularValues() << endl;\n\n\tfclose(matrix_file);\n\treturn 0;\n}\n", "meta": {"hexsha": "246f6fc900780bdf0fd095edd30bd8f8bb35bd6a", "size": 3461, "ext": "cpp", "lang": "C++", "max_stars_repo_path": "software/libvot/src/examples/euclidean_matrix.cpp", "max_stars_repo_name": "zyxrrr/GraphSfM", "max_stars_repo_head_hexsha": "1af22ec17950ffc8a5c737a6a46f4465c40aa470", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 181.0, "max_stars_repo_stars_event_min_datetime": "2015-09-18T13:46:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T06:14:11.000Z", "max_issues_repo_path": "software/libvot/src/examples/euclidean_matrix.cpp", "max_issues_repo_name": "zyxrrr/GraphSfM", "max_issues_repo_head_hexsha": "1af22ec17950ffc8a5c737a6a46f4465c40aa470", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 23.0, "max_issues_repo_issues_event_min_datetime": "2015-12-29T21:39:16.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-31T10:44:36.000Z", "max_forks_repo_path": "software/libvot/src/examples/euclidean_matrix.cpp", "max_forks_repo_name": "zyxrrr/GraphSfM", "max_forks_repo_head_hexsha": "1af22ec17950ffc8a5c737a6a46f4465c40aa470", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 60.0, "max_forks_repo_forks_event_min_datetime": "2015-09-18T13:46:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-09T03:26:07.000Z", "avg_line_length": 30.9017857143, "max_line_length": 101, "alphanum_fraction": 0.717711644, "num_tokens": 901, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673359709795, "lm_q2_score": 0.7371581684030623, "lm_q1q2_score": 0.5992117965390439}} {"text": "#pragma once\n\n#include \"Combinations.hpp\"\n#include \"DyckPaths.hpp\"\n#include \n\nnamespace discreture\n{\n\n////////////////////////////////////////////////////////////////////////////////////\n/// \\brief Class for iterating through all motzkin paths.\n/// \\param IntType must be a SIGNED integer type.\n///\n/// Motzkin paths are paths that go from \\f$(0,0)\\f$ to \\f$(0,2n)\\f$,\n/// which never go below the \\f$ y=0\\f$ line, in which each step is from\n/// \\f$(x,y)\\f$ to either \\f$(x+1,y+1)\\f$ or \\f$(x+1,y-1)\\f$ or \\f$(x+1,y)\\f$\n/// #Example Usage:\n///\n///\t\tmotzkin_paths X(4)\n///\t\tfor (auto&& x : X)\n///\t\t\tcout << x << endl;\n/// Prints out:\n///\t\t[ 0 0 0 0 ]\n///\t\t[ 1 -1 0 0 ]\n///\t\t[ 1 0 -1 0 ]\n///\t\t[ 0 1 -1 0 ]\n///\t\t[ 1 0 0 -1 ]\n///\t\t[ 0 1 0 -1 ]\n///\t\t[ 0 0 1 -1 ]\n///\t\t[ 1 1 -1 -1 ]\n///\t\t[ 1 -1 1 -1 ]\n///\n///\n/// # Example: Parenthesis\n///\n/// \tmotzkin_paths X(4)\n/// \tfor (auto&& x : X)\n/// \t\tcout << motzkin_paths::to_string(x, \"(-)\") << endl;\n///\n/// Prints out:\n///\t\t----\n///\t\t()--\n///\t\t(-)-\n///\t\t-()-\n///\t\t(--)\n///\t\t-(-)\n///\t\t--()\n///\t\t(())\n///\t\t()()\n///\n/////////////////////////////////////////////////////////////////////////////////////\n\ntemplate >\nclass MotzkinPaths\n{\npublic:\n static_assert(std::is_integral::value,\n \"Template parameter IntType must be integral\");\n static_assert(std::is_signed::value,\n \"Template parameter IntType must be signed\");\n using value_type = RAContainerInt;\n using motzkin_path = value_type;\n using difference_type = std::ptrdiff_t;\n using size_type = difference_type;\n using comb_i = typename Combinations::iterator;\n using dyck_i = typename DyckPaths::iterator;\n class iterator;\n using const_iterator = iterator;\n\n static std::string to_string(const motzkin_path& data,\n const std::string& delim = \"(-)\")\n {\n std::string toReturn;\n\n for (auto i : data)\n {\n auto j = 1 - i;\n toReturn.push_back(delim[j]);\n }\n\n return toReturn;\n }\n\n // **************** End static functions\n\npublic:\n ////////////////////////////////////////////////////////////\n /// \\brief Constructor\n ///\n /// \\param n is an integer >= 0\n ///\n ////////////////////////////////////////////////////////////\n explicit MotzkinPaths(IntType n) : n_(n) {}\n\n ////////////////////////////////////////////////////////////\n /// \\brief The total number of motzkin_paths\n ///\n /// \\return M_n\n ///\n ////////////////////////////////////////////////////////////\n size_type size() const { return motzkin(n_); }\n\n IntType get_n() const { return n_; }\n\n iterator begin() const { return iterator(n_); }\n\n iterator end() const { return iterator::make_invalid_with_id(size()); }\n\n ////////////////////////////////////////////////////////////\n /// \\brief Forward iterator class.\n ////////////////////////////////////////////////////////////\n class iterator\n : public boost::iterator_facade\n {\n public:\n iterator() : data_(), comb_(), dyck_() {} // empty initializer\n\n explicit iterator(IntType n) : data_(n, 0), comb_(n, 0), dyck_(0) {}\n\n size_type ID() const { return ID_; }\n\n static iterator make_invalid_with_id(size_type id)\n {\n iterator it;\n it.ID_ = id;\n return it;\n }\n\n private:\n void increment()\n {\n ++ID_;\n auto n = data_.size();\n\n if (ID_ == motzkin(n))\n return;\n\n ++comb_;\n if (comb_.is_at_end(n))\n {\n ++dyck_;\n\n if (dyck_.is_at_end(num_nonzero_halved_))\n {\n num_nonzero_halved_ += 1;\n\n dyck_.reset(num_nonzero_halved_);\n }\n\n comb_.reset(n, 2*num_nonzero_halved_);\n }\n\n ConvertToMotzkin(); // TODO(mraggi): do this laziliy\n }\n\n const motzkin_path& dereference() const { return data_; }\n\n bool equal(const iterator& it) const { return it.ID() == ID(); }\n\n private:\n size_type ID_{0};\n motzkin_path data_;\n comb_i comb_;\n dyck_i dyck_;\n IntType num_nonzero_halved_{0};\n\n void ConvertToMotzkin()\n {\n // \t\t\t\tcout << \"Converting: \" << *comb_ << \" and \" <<\n // *dyck_\n // << endl;\n for (size_t i = 0; i < data_.size(); ++i)\n {\n data_[i] = 0;\n }\n\n size_t count = 0;\n\n for (auto x : (*comb_))\n {\n data_[x] = (*dyck_)[count];\n ++count;\n }\n }\n\n friend class boost::iterator_core_access;\n }; // end class iterator\n\nprivate:\n IntType n_;\n}; // end class MotzkinPaths\n\nusing boost::container::static_vector;\n\nusing motzkin_paths = MotzkinPaths;\nusing motzkin_paths_stack = MotzkinPaths>;\n\n} // namespace discreture\n", "meta": {"hexsha": "1d870076e84374a7afb44ef61cad1440a0d7563a", "size": 5255, "ext": "hpp", "lang": "C++", "max_stars_repo_path": "include/Discreture/Motzkin.hpp", "max_stars_repo_name": "remz1337/discreture", "max_stars_repo_head_hexsha": "f15227a3e5c4faf04621bc9b2adad937aee06898", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 53.0, "max_stars_repo_stars_event_min_datetime": "2016-08-25T07:40:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-26T09:27:31.000Z", "max_issues_repo_path": "include/Discreture/Motzkin.hpp", "max_issues_repo_name": "remz1337/discreture", "max_issues_repo_head_hexsha": "f15227a3e5c4faf04621bc9b2adad937aee06898", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 27.0, "max_issues_repo_issues_event_min_datetime": "2020-06-06T18:32:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-02T22:16:49.000Z", "max_forks_repo_path": "sources/include/external/Discreture/Motzkin.hpp", "max_forks_repo_name": "greati/logicantsy", "max_forks_repo_head_hexsha": "11d1f33f57df6fc77c3c18b506fc98f9b9a88794", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12.0, "max_forks_repo_forks_event_min_datetime": "2018-03-12T05:42:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-13T23:18:32.000Z", "avg_line_length": 26.4070351759, "max_line_length": 100, "alphanum_fraction": 0.4690770695, "num_tokens": 1329, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673087708698, "lm_q2_score": 0.7371581626286834, "lm_q1q2_score": 0.5992117717944571}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \"RBF.h\"\r\n#include \"MLS.h\"\r\n#include \"HermiteRBF.h\"\r\n#include \"GeneralizedMLS.h\"\r\n#include \r\n#include \r\n#include \r\nusing namespace std;\r\nusing namespace kt84;\r\nnamespace mpl = boost::mpl;\r\n\r\n// utility for interpolation algorithms |\r\n//--------------------------------------+\r\ntemplate